/LMAR=0/XLINE=20/FONT#0=BASL30.FNT[ IJ,DBL]/FONT#1=BASB30.FNT[XGP,SYS]/FONT#2=NGR25.FNT[XGP,SYS]/FONT#3=BASI30.FNT[ IJ,DBL]/FONT#4=NGR40.FNT[XGP,SYS]/FONT#6=FIX20.FNT[XGP,SYS]
␈↓ d␈↓␈α?␈α?␈α9␈↓∧SYNTHESIS OF LARGE PROGRAMS FROM SPECIFIC DIALOGUES␈↓

␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α8Douglas B. Lenat
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∃Stanford Artificial Intelligence Laboratory
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α&Stanford, California

␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α	␈↓∧␈↓&ABSTRACT␈↓)αβ␈↓

␈↓"/␈↓ d␈↓Automatic␈α∃programming␈α∃must␈α⊗eventually␈α∃deal␈α∃with␈α⊗large␈α∃programs.␈α∃Using␈α⊗the␈α∃paradigm␈α∃of␈α⊗dialogue,␈α∃a
␈↓ d␈↓preliminary␈αstudy␈αwas␈αdone␈αon␈αtasks␈αtens␈αof␈αpages␈αlong,␈αrequiring␈αseveral␈αhours␈αof␈αuser-system␈α
interaction␈αtime
␈↓ d␈↓to␈α∂synthesize.␈α∂Many␈α∂assumptions␈α∂which␈α∂are␈α∂reasonable␈α∂when␈α∂concentrating␈α∂upon␈α∂tiny␈α∂targets␈α∂become␈α∂limiting
␈↓ d␈↓factors␈αin␈αlarge␈αdialogues.␈αAn␈αexperimental␈αsystem,␈αPUP6,␈αwas␈αconstructed.␈α The␈αmethods␈αit␈αemploys␈αto␈αgenerate
␈↓ d␈↓target␈α
code␈α
are␈α
not␈α∞formal,␈α
but␈α
rather␈α
involve␈α
structuring␈α∞of␈α
knowledge␈α
about␈α
programming,␈α
about␈α∞the␈α
chosen
␈↓ d␈↓task␈αdomain␈α(inductive␈αinference␈αLISP␈αprograms),␈αand␈αabout␈αtransfer␈αof␈αcontrol.␈αSpecification␈αis␈αvia␈αlong,␈αbrittle
␈↓ d␈↓dialogues␈α∞with␈α
the␈α∞user,␈α
but␈α∞is␈α
only␈α∞partial:␈α
ambiguities␈α∞are␈α
resolved␈α∞by␈α
inference␈α∞and␈α
deferral.␈α∞ Knowledge␈α
is
␈↓ d␈↓represented␈α∞as␈α∞a␈α∞pool␈α∞of␈α
structured␈α∞modules,␈α∞whose␈α∞abilities␈α∞include␈α
asking␈α∞and␈α∞answering␈α∞questions␈α∞posed␈α
by
␈↓ d␈↓each␈α
other␈α
or␈α
by␈α
the␈α
user.␈α
 Inadvertantly,␈α
a␈α
new␈α∞style␈α
of␈α
target␈α
program␈α
was␈α
synthesized:␈α
like␈α
PUP6,␈α
it␈α∞can␈α
be
␈↓ d␈↓interrupted␈α∞as␈α∞it␈α∂runs␈α∞and␈α∞queried␈α∞about␈α∂what␈α∞it's␈α∞doing.␈α∞ This␈α∂research␈α∞revealed␈α∞some␈α∞major␈α∂difficulties␈α∞the
␈↓ d␈↓"next generation" of automatic synthesis systems must face.
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α<␈↓∧␈↓&1. Motivation␈↓)αβ␈↓
␈↓"/␈↓ d␈↓Artificial␈α∩Intelligence␈α∩systems␈α∪[e.g.,␈α∩9]␈α∩are␈α∩currently␈α∪experimentally␈α∩generating␈α∩small␈α∩programs,␈α∪from␈α∩partial
␈↓ d␈↓specificiations␈αin␈αan␈αambiguous␈αlanguage.␈α
 The␈αefforts␈αon␈αsynthesis␈αof␈α
large␈αprograms␈αare␈αlimited␈αto␈αefficient␈α
but
␈↓ d␈↓routine␈α↔transformations,␈α↔compilations␈α↔of␈α↔well-specified␈α_programs␈α↔in␈α↔higher␈α↔languages␈α↔(e.g.,␈α_by␈α↔heuristic
␈↓ d␈↓compilers).␈α The␈αformer␈αsystems␈αrecognize␈αthat␈αlarger␈αcapabilities␈αare␈αprerequisite␈αto␈αutility,␈αbut␈α(correctly)␈αargue
␈↓ d␈↓that mastery of small tasks must precede mastery of large ones.
␈↓"/␈↓ d␈↓Despite␈α∩the␈α⊃small␈α∩chance␈α⊃for␈α∩success␈α⊃in␈α∩aiming␈α⊃at␈α∩ambitious␈α⊃targets,␈α∩it␈α⊃is␈α∩important␈α⊃to␈α∩attempt␈α⊃it,␈α∩at␈α⊃least
␈↓ d␈↓occasionally.␈α
The␈α
analogy␈α
between␈α
the␈α
construction␈α
of␈α∞a␈α
10-line␈α
program,␈α
in␈α
five␈α
minutes␈α
of␈α
dialogue,␈α∞and␈α
the
␈↓ d␈↓construction of a 100-page program, in five hours of dialogue, is at best superficial.
␈↓"/␈↓ d␈↓A␈α∂system,␈α∞PUP6,␈α∂was␈α∞partially␈α∂implemented␈α∞to␈α∂study␈α∂this␈α∞task.␈α∂It␈α∞did␈α∂ultimatedly␈α∞synthesize␈α∂three␈α∂large␈α∞LISP
␈↓ d␈↓programs:␈α↔a␈α⊗concept␈α↔formation␈α↔program,␈α⊗a␈α↔grammatical␈α⊗inference␈α↔program,␈α↔and␈α⊗a␈α↔simple␈α↔property␈α⊗list
␈↓ d␈↓maintenance␈α
routine␈α
(referred␈α
to␈α
as␈α
CF,␈α
GI,␈α
and␈α
PL).␈α
Some␈α
unanticipated␈α
dificulties␈α
were␈α
encountered␈αwhich␈α
may
␈↓ d␈↓be inherent in syntheses of this magnitude.

␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α)␈↓∧␈↓&2. Task␈↓)αβ␈↓
␈↓"/␈↓ d␈↓The␈α∩task␈α∩of␈α∪synthesizing␈α∩large␈α∩INTERLISP[10]␈α∩programs,␈α∪from␈α∩long␈α∩specific␈α∩dialogues␈α∪with␈α∩a␈α∩user,␈α∪in␈α∩a
␈↓ d␈↓restricted subset of English, was considered. This activity will be referred to as ␈↓βautomatic programming␈↓.
␈↓"/␈↓ d␈↓The␈α
first␈αquestion␈α
to␈αsettle␈α
in␈αsuch␈α
an␈αendeavor␈α
is␈α
what␈αthe␈α
␈↓βtarget␈αprograms␈↓␈α
(the␈αgenerated␈α
code)␈αare␈α
going␈αto␈α
be.
␈↓ d␈↓More␈α
generally,␈α
what␈αis␈α
the␈α
 domain␈α
of␈αthe␈α
target␈α
programs?␈α
A␈αlarge␈α
amount␈α
of␈α
effort␈αwas␈α
spent␈α
on␈αthis␈α
question,
␈↓ d␈↓and␈α∃the␈α∃chosen␈α∃domain␈α∃was␈α∃inductive␈α∃inference␈α⊗programs.␈α∃The␈α∃obvious␈α∃problem␈α∃here␈α∃is␈α∃the␈α⊗size␈α∃and
␈↓ d␈↓sophistocation of the targets, but there are four big attractions:
␈↓"/␈↓ d␈↓(i) A  wide  range  of  complexity  exists,  from  a  one-page   sequence extrapolator   to   Meta-Dendral.
␈↓"/␈↓ d␈↓(ii)␈α  Each␈α  increasingly␈αsophisticated␈αinductive␈αinference␈αprogram␈α uses␈α many␈α of␈α the␈α concepts␈α embodied␈α in
␈↓ d␈↓simpler  inductive inference programs.
␈↓"/␈↓ d␈↓(iii)␈α⊂If␈α⊂a␈α⊂super-human␈α⊂target␈α⊂program␈α⊂is␈α⊂ever␈α⊂written,␈α⊂it␈α⊂could␈α⊂itself␈α⊂contribute␈α⊂to␈α⊂the␈α⊂ field␈α⊃ of␈α⊂ Automatic
␈↓ d␈↓Programming! (This remark is humorous in the seventies, but may be commonplace someday.)
␈↓"/␈↓ d␈↓(iv)␈α⊗ Since␈α⊗people␈α⊗(especially␈α⊗scientific␈α⊗researchers)␈α⊗are␈α⊗the␈α⊗inductive␈α⊗inference␈α⊗experts,␈α⊗our␈α⊗reliance␈α∃on
␈↓ d␈↓introspection  is  as valid  --  and potentially as valuable -- as chemists' protocols were to Dendral.
␈↓"/␈↓ d␈↓After␈α studying␈α many␈α sample␈α programs␈α from␈α the␈αinductive␈αinference␈αdomain,␈αsequence␈αextrapolation␈αseemed
␈↓ d␈↓the␈α∂most␈α∂reasonable␈α∞ beginning␈α∂task.␈α∂It␈α∞was␈α∂quickly␈α∂learned␈α∞that␈α∂this␈α∂was␈α∞too␈α∂easy:␈α∂humans␈α∞have␈α∂only␈α∂a␈α∞few
␈↓ d␈↓techniques␈α⊃for␈α⊃extrapolating␈α⊃ sequences,␈α⊂ and␈α⊃ a␈α⊃ very␈α⊃ limited␈α⊂capacity␈α⊃  for␈α⊃  composing␈α⊃  them.␈α⊃  Thus␈α⊂ a
␈↓ d␈↓rather␈α∩ rigid␈α∩ sequence␈α⊃extrapolator␈α∩writer␈α∩may␈α∩be␈α⊃capable␈α∩of␈α∩generating␈α⊃ a␈α∩ large␈α∩ class␈α∩ of␈α⊃super-human
␈↓ d␈↓extrapolation programs (see section 4.2 on Sequence-Extrapolator-Writer, in [3]).
␈↓"/␈↓ d␈↓The␈α∂ next␈α∞ candidates␈α∂ were␈α∞grammatical␈α∂inference␈α∞and␈α∂concept␈α∞formation␈α∂[4].␈α∞ Determined␈α∂not␈α∞to␈α∂choose␈α∞too
␈↓ d␈↓simple␈α
 a␈α task␈α
 again,␈α the␈α
latter␈α
program␈αwas␈α
finally␈αdecided␈α
upon.␈α
 The␈αparticular␈α
target␈αwas␈α
similar␈α
to␈α[11],
␈↓ d␈↓except Winston's heuristic graph-matching algorithm was simplified.
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α	␈↓∧␈↓&3. Target program␈↓)αβ␈↓
␈↓"/␈↓ d␈↓It␈αseems␈αinstructive␈αnow␈αto␈αdescribe␈αin␈αdetail␈αhow␈αCF,␈αthe␈α target␈α program,␈αshould␈αoperate.␈αIt␈αrepeatedly␈αscans␈αa
␈↓ d␈↓scene␈α∞and␈α
tries␈α∞to␈α∞name␈α
it.␈α∞The␈α∞scene␈α
is␈α∞broken␈α∞into␈α
a␈α∞set␈α∞of␈α
features␈α∞and␈α∞a␈α
set␈α∞of␈α∞objects.␈α
Each␈α∞feature␈α∞is␈α
 a
␈↓ d␈↓relation␈αon␈α one␈α or␈α
 more␈α objects␈α in␈α the␈α
 scene.␈α Internally,␈α CF␈αmaintains␈α
a␈αmodel␈αfor␈αeach␈α
differently-named
␈↓ d␈↓scene␈α
it␈αhas␈α
ever␈αencountered.␈α
 The␈αmodel␈α
 contains␈α a␈α
 description␈α of␈α
 the␈αobjects␈α
expected␈αin␈α
the␈αscene,␈α
a␈αset␈α
of
␈↓ d␈↓features␈α
which␈α
must␈αbe␈α
present␈α
in␈αany␈α
scene␈α
having␈α
this␈αname,␈α
a␈α
set␈αof␈α
features␈α
which␈α
must␈αnot␈α
be␈α
present␈αin␈α
the
␈↓ d␈↓scene,␈αand␈αa␈α
set␈αof␈αfeatures␈α
which␈αmay␈αor␈α may␈α
 not␈αbe␈α present.␈α
 Thus␈α a␈αmodel␈αis␈α
an␈αarchtypical␈αscene␈α
plus␈αa
␈↓ d␈↓name.␈α
 Each␈α
time␈α
it␈αis␈α
confronted␈α
by␈α
a␈αnew␈α
scene,␈α
CF␈α
 must␈α
scan␈αits␈α
models␈α
until␈α
it␈αfinds␈α
one␈α
which␈α
matches␈αit.␈α
A
␈↓ d␈↓model␈αis␈αsaid␈α
to␈αmatch␈αa␈α
scene␈αif␈αall␈α
the␈αMUST␈αfeatures␈α
associated␈αwith␈αthat␈α
model␈αare␈αpresent␈α
in␈αthe␈αscene,␈α
and
␈↓ d␈↓all␈αthe␈α
MUSTNOT␈α features␈α are␈α
absent␈α from␈α the␈α
  scene.␈αCF␈αinforms␈α
the␈αuser␈αof␈α
this␈αguess,␈αand␈α
accepts␈αthe
␈↓ d␈↓proper␈α⊂ name.␈α⊂If␈α∂it␈α⊂ guessed␈α⊂ incorrectly,␈α⊂ it␈α∂modifies␈α⊂its␈α⊂models.␈α⊂The␈α∂wrong-guess␈α⊂model␈α⊂may␈α⊂have␈α∂features
␈↓ d␈↓added␈α∞to␈α
its␈α∞MUST␈α
or␈α∞MUSTNOT␈α
sets;␈α∞the␈α
correct-name␈α∞model␈α
may␈α∞have␈α
 to␈α∞be␈α
 modified␈α∞or␈α
(if␈α∞it's␈α∞a␈α
new
␈↓ d␈↓name) created and inserted into the list of models.
␈↓"	
␈↓"	␈↓ d␈↓For example, part of a scene might be:     
␈↓"	␈↓ d␈↓        OBJECTS a,b,c,d
␈↓"	␈↓ d␈↓        RELATIONS  (GREEN a) (BLUE c) (TOUCHES c d) (SUPPORTS a c) (SUPPORTS b c)
␈↓"	
␈↓"	␈↓ d␈↓A model for an arch might be:              
␈↓"	␈↓ d␈↓        NAME    ARCH
␈↓"	␈↓ d␈↓        OBJECTS a,b,c
␈↓"	␈↓ d␈↓        MUST    (SUPPORTS a c) (SUPPORTS b c)
␈↓"	␈↓ d␈↓        MUSTNOT (TOUCHES a b)
␈↓"	␈↓ d␈↓        MAY     (GREEN a) (WEDGE c) (PRISM a) (BLOCK b) (PARALLEL a b)
␈↓"/␈↓ d␈↓Suppose␈α that␈αthe␈αtarget␈αprogram␈αreads␈αin␈αthe␈αabove␈αscene␈αfragment␈αand␈αtries␈αto␈αmatch␈αit␈αto␈α the␈α above␈α model
␈↓ d␈↓for␈α consistency.␈α The␈α MUST␈αrelations␈α should␈α all␈α be␈α present.␈α  Yes,␈α the␈α scene␈α does␈αcontain␈α(SUPPORTS␈αa
␈↓ d␈↓c)␈α⊃and␈α⊃(SUPPORTS␈α⊃b␈α⊃c).␈α⊂Next,␈α⊃the␈α⊃MUSTNOT␈α⊃ relations␈α⊃ must␈α⊂be␈α⊃absent␈α⊃from␈α⊃the␈α⊃scene.␈α⊃Sure␈α⊂enough,
␈↓ d␈↓(TOUCHES␈α
a␈αb)␈α
isn't␈αthere.␈α
 So␈αthe␈α
model␈αand␈α
scene␈αare␈α
consistent,␈αand␈α
the␈αprogram␈α
announces␈αthat␈α
its␈αguess␈α
is
␈↓ d␈↓ARCH.␈α If␈αthe␈αuser␈αverifies␈αthis␈αguess,␈αthen␈α the␈α
MAY␈αset␈αis␈αaugmented␈αwith␈α(BLUE␈αc)␈αand␈α(TOUCHES␈α
c␈αd),
␈↓ d␈↓and the OBJECTS set is augmented with "d."
␈↓"/␈↓ d␈↓If␈α
the␈α
user␈α
denies␈α
that␈α
the␈α
scene␈α
is␈α
an␈α
arch,␈α
the␈α
target␈α
program␈α
sees␈α
if␈α
there␈α
are␈α
any␈α
relations␈α
in␈α
the␈αmodel's␈α
MAY
␈↓ d␈↓set␈α
which␈α
do␈α
not␈α
occur␈α
in␈α
the␈α
scene.␈α
If␈α
so,␈α
one␈α
of␈α
them␈α
(e.g.,␈α
(PARALLEL␈α
a␈α
b))␈α
will␈α
be␈α
transferred␈α
from␈α
the␈α
MAY
␈↓ d␈↓to␈α∞the␈α∞MUST␈α∞set.␈α∞ If␈α∞no␈α
such␈α∞feature␈α∞existed,␈α∞the␈α∞program␈α∞would␈α∞look␈α
for␈α∞a␈α∞feature␈α∞present␈α∞in␈α∞the␈α∞scene␈α
but
␈↓ d␈↓absent␈αfrom␈αall␈αsets␈αof␈αthe␈αmodel␈α(e.g.,␈α(TOUCHES␈αc␈αd)),␈αand␈αinsert␈αit␈αinto␈αthe␈αMUSTNOT␈αset.␈α In␈αeither␈αcase,
␈↓ d␈↓the␈α
user␈αwould␈α
be␈α
asked␈αwhat␈α
the␈α
true␈αname␈α
was,␈α
and␈αthat␈α
model␈α
would␈αhave␈α
its␈α
MAY␈αset␈α
augmented␈α
by␈αany
␈↓ d␈↓new␈α
features␈αin␈α
the␈αscene.␈α
Any␈αfeatures␈α
on␈αits␈α
MUST␈α
or␈αMUSTNOT␈α
sets␈αwhich␈α
contradicted␈αthe␈α
scene␈αwould␈α
be
␈↓ d␈↓transferred to the MAY set.
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α/␈↓∧␈↓&4. Annotated protocol␈↓)αβ␈↓
␈↓ d␈↓After␈α∞the␈α∞target␈α∞concept␈α∞formation␈α
program␈α∞was␈α∞specified,␈α∞ it␈α∞was␈α
trimmed␈α∞and␈α∞then␈α∞rewritten␈α∞as␈α∞a␈α
structured
␈↓ d␈↓program␈α∪[2].␈α∪Next,␈α∪a␈α∪complete␈α∪dialogue␈α∪was␈α∪ simulated␈α∪ between␈α∪ the␈α∪ user␈α∪ and␈α∪ a␈α∀ human␈α∪programmer
␈↓ d␈↓(referred␈α
to␈αas␈α
the␈α
system-player)␈αplaying␈α
the␈α
role␈αof␈α
an␈α
"intelligent"␈α automatic␈α
 programming␈α
 system␈α (similar
␈↓ d␈↓to,␈α
  e.g.,␈α
[1]).␈α
     The␈α
  system-player␈α
  kept␈α
  careful␈α
 records␈α
 as␈α
 he␈α
programmed,␈α
and␈α
tried␈α
to␈α
create␈αa␈α
bug-free
␈↓ d␈↓structured␈α∞ program.␈α
 The␈α∞dialogue␈α
 was␈α∞ then␈α
annotated:␈α∞    after␈α
each␈α∞user␈α
response,␈α∞comments␈α∞were␈α
inserted
␈↓ d␈↓which␈α∩described␈α∩the␈α⊃"states"␈α∩the␈α∩system-player␈α∩had␈α⊃gone␈α∩through␈α∩before␈α⊃printing␈α∩his␈α∩next␈α∩response.␈α⊃ This
␈↓ d␈↓included␈α
blind␈α
paths␈α
which␈α
were␈α
tried,␈α
use␈α
of␈α
outside␈α
world␈α
knowledge,␈α
 and,␈α
 in␈α
 general,␈α
was␈α
 meant␈α
 to␈α
 be␈α
 the
␈↓ d␈↓"reasoning"␈αnecessary␈αto␈αdo␈αthe␈αtask.␈α The␈αfear␈αwas␈αthat␈αa␈αsystem␈αcould␈αbe␈αbuilt␈αwhich␈αsynthesized␈α the␈α concept
␈↓ d␈↓formation␈α program,␈α
 and␈α yet␈α was␈α
 so␈αunintelligent␈α
that␈αnothing␈αwas␈α
learned␈αfrom␈αit.␈α
(for␈αexample,␈α
see␈αsection
␈↓ d␈↓4.1 on PW1  in  [3]).
␈↓"/␈↓ d␈↓The␈α∞central␈α∞goals␈α∞in␈α∞writing␈α∞PUP6␈α∞were␈α∞that␈α∞it␈α∞(i)␈α∞get␈α∞the␈α∞target␈α∞program␈α∞CF␈α∞correctly,␈α∞(ii)␈α∞follow␈α∞this␈α∞initial
␈↓ d␈↓dialogue,␈α
and,␈α
most␈α
importantly,␈α
(iii)␈αgo␈α
through␈α
 the␈α
 same␈α
 line␈αof␈α
reasoning␈α
that␈α
the␈α
comments␈α
indicated␈αthe
␈↓ d␈↓system-player␈α
followed.␈α
PU6␈α
would␈α∞be␈α
far␈α
along␈α
the␈α∞road␈α
toward␈α
utility␈α
if␈α
it␈α∞also␈α
 (iv)␈α
 could␈α
write␈α∞ the␈α
target
␈↓ d␈↓program␈α from␈αseveral␈α
dialogues,␈αfrom␈αseveral␈αusers,␈α
with␈αlittle␈αpreparation.␈αPUP6␈α
was␈αnot␈αdesigned␈αto␈α
do␈αthis,
␈↓ d␈↓and␈α
in␈α
the␈α
 end␈α∞it␈α
 proved␈α
to␈α
be␈α
a␈α∞serious␈α
deficit.␈α
 Henceforth,␈α
␈↓βprotocol␈↓␈α
will␈α∞refer␈α
to␈α
this␈α
user-player␈α∞/␈α
system-
␈↓ d␈↓player simulated dialogue.
␈↓"/␈↓ d␈↓A␈α
corollary␈αof␈α
this␈αincremental␈α
annotated␈α
protocol␈αapproach␈α
is␈αthat␈α
the␈α
abilities␈αof␈α
the␈αuser␈α
must␈α
coincide␈αwith
␈↓ d␈↓those␈α
 of␈α∞ the␈α
 subject␈α∞ who␈α
participated␈α
 in␈α∞the␈α
protocol.␈α∞The␈α
target␈α
user␈α∞must␈α
be␈α∞familiar␈α
with␈α∞ LISP,␈α
 well-
␈↓ d␈↓grounded␈α
 in␈α
 computer␈α
 science,␈α  and␈α
  have␈α
  the␈α
input/output␈α
 behavior␈α of␈α
CF,␈α
the␈α
concept␈α formation␈α
 target
␈↓ d␈↓program,␈α
very␈α
clearly␈αin␈α
his␈α
mind.␈α
The␈αnatural␈α
language␈α
front␈α
 end␈α is␈α
 so␈α
 brittle␈α
that␈α the␈α
user␈α
must␈αalso␈α
phrase
␈↓ d␈↓his responses very similarly to those of the original protocol subject.
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α"␈↓∧␈↓&5. The BEINGs scheme␈↓)αβ␈↓
␈↓"/␈↓ d␈↓The␈αnext␈αmajor␈αdesign␈αissue␈αis␈αthe␈αinternal␈α
mechanism␈αfor␈αachieving␈αthis␈αtask.␈α The␈αearlier␈αPUP␈α
programs␈α[3]
␈↓ d␈↓had␈α
taught␈α
the␈αauthor␈α
to␈α
organize␈α
the␈αsystem␈α
knowledge␈α
in␈αways␈α
meaningful␈α
to␈α
how␈αit␈α
would␈α
be␈α
needed.␈αThis
␈↓ d␈↓need␈α⊃for␈α⊃structuring␈α⊃is␈α⊃also␈α⊃echoed␈α⊃in␈α⊃[7].␈α⊃ Many␈α⊃people,␈α⊃however,␈α⊃champion␈α⊃the␈α⊃merits␈α⊃of␈α⊃uniformity:␈α⊂ in
␈↓ d␈↓particular,␈αconceptually␈αeasy␈αaddition␈αof␈α
new␈αknowledge,␈αand␈αmore␈αstandardized␈α(hence␈α
simpler)␈αcommunication
␈↓ d␈↓and␈α∞interaction␈α∂between␈α∞the␈α∂knowledge.␈α∞ Not␈α∂wishing␈α∞to␈α∞give␈α∂up␈α∞these␈α∂advantages,␈α∞a␈α∂compromise␈α∞mechanism,
␈↓ d␈↓BEINGs, was developed.
␈↓"/␈↓ d␈↓A␈αBEING␈αis␈αa␈αloosely-knit␈αlittle␈αexpert,␈αa␈αcollection␈αof␈αabout␈αthirty␈αdifferent␈αquestions␈αand␈αtheir␈αanswers.␈α Each
␈↓ d␈↓part␈α⊃of␈α⊃a␈α⊂BEING␈α⊃is␈α⊃therefore␈α⊂an␈α⊃explanation␈α⊃of␈α⊂some␈α⊃facet␈α⊃of␈α⊂the␈α⊃BEING.␈α⊃ A␈α⊂small␈α⊃expert␈α⊃is␈α⊂considered
␈↓ d␈↓␈↓βequivalent␈↓ to its answers to a couple dozen queries.
␈↓ d␈↓So␈α∞far,␈α∞this␈α
representation␈α∞is␈α∞isomorphic␈α
to␈α∞the␈α∞ACTOR[5]␈α
formalism.␈α∞ The␈α∞structure␈α
is␈α∞present,␈α∞all␈α∞right,␈α
but
␈↓ d␈↓what␈α∂about␈α∂the␈α∂uniformity?␈α∂It␈α∂seems␈α∞that␈α∂one␈α∂can't␈α∂add␈α∂a␈α∂new␈α∞BEING␈α∂(write␈α∂its␈α∂parts)␈α∂unless␈α∂he␈α∂knows␈α∞the
␈↓ d␈↓particular␈αquestions␈αhe␈αcan␈αask␈αeach␈αother␈αBEING␈αin␈αthe␈αsystem,␈αand␈αthat␈αone␈αBEING␈αcan't␈αcommunicate␈αwith
␈↓ d␈↓another unless it specifically knows what that BEING can be asked.
␈↓"/␈↓ d␈↓Both␈α
these␈α
problems␈αtheoretically␈α
disappear␈α
if␈αthe␈α
set␈α
of␈αthirty␈α
questions␈α
is␈α␈↓βfixed␈↓␈α
once␈α
and␈αfor␈α
all.␈α
 That␈α
is,␈αlet
␈↓ d␈↓every␈αBEING␈αconsist␈αof␈α
answers␈αto␈αa␈αsingle␈αset␈α
of␈αquestions,␈αand␈αlet␈αthe␈α
user␈αand␈αevery␈αBEING␈αhave␈α
access␈αto
␈↓ d␈↓(and implicit understanding of) each question.
␈↓"/␈↓ d␈↓Of␈α∂course␈α∂the␈α∂number␈α∂thirty␈α∂is␈α∂arbitrary,␈α∂but␈α∂it␈α∂should␈α∂not␈α∂be␈α∂ignored␈α∂completely.␈α∂ By␈α∂choosing␈α∂it␈α∂to␈α∂be␈α∞~1
␈↓ d␈↓instead,␈αa␈αcompletely␈αuniform␈αrepresentation␈α(e.g.,␈αPredicate␈αCalculus)␈αis␈αdetermined.␈α By␈αallowing␈αit␈αto␈αbe␈α~1000,
␈↓ d␈↓one␈α∞could␈α∞simply␈α∞take␈α∂the␈α∞union␈α∞of␈α∞all␈α∂the␈α∞questions␈α∞any␈α∞BEING␈α∞wanted,␈α∂and␈α∞thus␈α∞all␈α∞the␈α∂uniformity␈α∞would
␈↓ d␈↓disappear.␈α
 The␈α
number␈α
of␈α
BEING␈α
parts␈α
is␈αtherefore␈α
a␈α
parameter␈α
expressing␈α
the␈α
degreee␈α
of␈αcompromise␈α
between
␈↓ d␈↓structure and standardization in the community of BEINGs.
␈↓"/␈↓ d␈↓The␈α
specific␈α
BEING␈α
parts␈α
chosen␈α
have␈α
much␈α
to␈α
do␈α
with␈α
the␈α
epistemology␈α
of␈α
programming.␈α
 The␈α
tentative␈α
set
␈↓ d␈↓implemented␈αin␈αPUP6␈αare␈αlisted␈αbelow,␈αfollowed␈αby␈αa␈αbrief␈αdescription␈αand␈αthe␈αpercentage␈αof␈αthe␈αoriginal␈αPUP6
␈↓ d␈↓pool which actually wanted the part specified.

␈↓"	␈↓ d␈↓␈↓↓IDEN␈↓ 54%  How is this BEING referenced in English phrases? Implemented as productions.
␈↓"	␈↓ d␈↓␈↓↓ARGS␈↓ 63%  How many arguments? Which are optional? Are there any local variables?
␈↓"	␈↓ d␈↓␈↓↓ARG-CHECK␈↓ 81%  Predicates which examine each argument for suitability.
␈↓"	␈↓ d␈↓␈↓↓EVAL-ARGS␈↓  4%  Which arguments are to be evaluated, and which quoted?
␈↓"	␈↓ d␈↓␈↓↓WHAT␈↓ 82%  A brief summary of the global purpose. Usually a template for an English sentence.
␈↓"	␈↓ d␈↓␈↓↓WHY␈↓ 77%  A justification of the BEING's existence. The caller explains here why it was called.
␈↓"	␈↓ d␈↓␈↓↓HOW␈↓ 72%  A summary of the methods the BEING intends to employ. Global strategies.
␈↓"	␈↓ d␈↓␈↓↓EFFECTS␈↓ 27%  What will probably be true after this BEING is through? What can it achieve?
␈↓"	␈↓ d␈↓␈↓↓WHEN␈↓ 19%  Why should this BEING be given control now? Computed as the sum of weighted factors.
␈↓"	␈↓ d␈↓␈↓↓META-CODE␈↓ 70%  The body of the executable code, but with uninstantiated subparts.
␈↓"	␈↓ d␈↓␈↓↓COMMENTS␈↓ 16%  Hints for filling in undefined sections of other BEING parts.
␈↓"	␈↓ d␈↓␈↓↓REQUISITES␈↓ 10%  If this BEING is actually chosen, what must be made true just before (pre-),
␈↓"	␈↓ d␈↓during (co-), and after (post-) execution?  Work to make these true (unlike ARG-CHECK).
␈↓"	␈↓ d␈↓␈↓↓DEMONS␈↓ 7%  Which demons should be kept active while the BEING is in control?
␈↓"	␈↓ d␈↓␈↓↓AFFECTS␈↓ 14%  Which other BEINGs might be called by this BEING, and why?
␈↓"	␈↓ d␈↓␈↓↓COMPLEXITY␈↓ 92%  A vector of utility measures, including ease of calling, chance of success, chance
␈↓"	␈↓ d␈↓of (calling)* itself, expected time cost, efficiency of its output results.
␈↓"	␈↓ d␈↓␈↓↓SPECIALIZATIONS␈↓ 40%  How to write a more streamlined, special-case version of this BEING.
␈↓"	␈↓ d␈↓␈↓↓GENERALIZATIONS␈↓ 27%  What are some other BEINGs, encompassing this one?
␈↓"	␈↓ d␈↓␈↓↓ALTERNATIVES␈↓ 16%  What are some equivalent BEINGs? (to try if this one fails)
␈↓"	␈↓ d␈↓␈↓↓RESULTS␈↓ 15%  How many values does this return? What domain is each in? Any side effects?
␈↓"	␈↓ d␈↓␈↓↓STRUCTURE␈↓ 4% If this is ever viewed as a data structure, what operations are done to it, and how?
␈↓"	␈↓ d␈↓␈↓↓ENCODABLE␈↓ 9%  How to order the evaluation of the other parts, when writing a new version.
␈↓ d␈↓␈↓↓FORM-CHANGING␈↓ 1% Should the entire structure of an existing BEING be radically altered?
␈↓"	␈↓ d␈↓␈↓↓INHIBIT-DEMONS␈↓  5%  A lock/unlock mechanism, useful when handling demonic interrupts.
␈↓"/␈↓ d␈↓The␈α
operational␈α∞details␈α
of␈α
each␈α∞part␈α
will␈α
be␈α∞explained␈α
by␈α
dissecting␈α∞OBTAIN-USABLE-INFORMATION,␈α
a
␈↓ d␈↓high-level,␈α∂domain-independent␈α∂BEING.␈α∂For␈α⊂each␈α∂part␈α∂is␈α∂listed␈α∂its␈α⊂name,␈α∂a␈α∂typical␈α∂question␈α∂which␈α⊂it␈α∂would
␈↓ d␈↓answer,␈αits␈α
answer,␈αthe␈αLISP␈α
program␈αstored␈αas␈α
the␈αvalue␈αof␈α
that␈αpart␈αin␈α
OBTAIN-USABLE-INFORMATION
␈↓ d␈↓(the way it computed the answer), and a brief discussion.


␈↓"	␈↓ d␈↓α␈↓↓IDEN␈↓α         Can you recognize this: "Find out more about frobs"?           ␈↓↓Yes, I can.␈↓α
␈↓"	␈↓ d␈↓α   ((if you see: (OBTAIN-USABLE-INFORMATION any1)
␈↓"	␈↓ d␈↓α                 then return: (OBTAIN-USABLE-INFORMATION (TRANSLATE any1)))
␈↓"	␈↓ d␈↓α    (if you see:(FIND OUT MORE ABOUT any1)
␈↓"	␈↓ d␈↓α                 then return:(OBTAIN-USABLE-INFORMATION any1)))
␈↓"/␈↓ d␈↓Each␈αBEING␈αis␈αgiven␈αthe␈αduty␈αto␈αrecognize␈αand␈αprocess␈αEnglish␈αphrases␈αrelated␈αto␈αhim.␈α In␈αpractice,␈αonly␈αa␈αfew
␈↓ d␈↓simple␈α∞phrase␈α∂templates␈α∞were␈α∂needed␈α∞for␈α∂each␈α∞BEING;␈α∂OBTAIN-USABLE-INFORMATION␈α∞only␈α∂used␈α∞two
␈↓ d␈↓patterns.␈α∂ All␈α∂the␈α∂IDEN␈α∂parts␈α∂are␈α∂collected␈α∂together␈α∂into␈α∂one␈α∂table.␈α∂ When␈α∂a␈α∂form␈α∂␈↓βF␈↓␈α∂must␈α∂be␈α⊂translated,␈α∂the
␈↓ d␈↓TRANSLATE␈αBEING␈α
takes␈αcontrol␈α
and␈α(by␈α
searching␈αthis␈αtable)␈α
asks␈α"who␈α
can␈αrecognize␈α
␈↓βF␈↓?"␈α Each␈αIDEN␈α
part
␈↓ d␈↓runs␈αa␈αlittle␈αprogram␈α(typically␈αa␈αpattern-match),␈αthen␈αreplies␈αeither␈αNO,␈αor␈αelse␈αprovides␈αa␈αlittle␈αprogram␈αwhose
␈↓ d␈↓value␈αshould␈αbe␈αthe␈αtranslation␈αof␈α␈↓βF␈↓.␈α If␈αthere␈αis␈αmore␈αthan␈αone␈αresponder,␈αa␈αglobal␈αchoice␈αBEING,␈αCHOOSE-
␈↓ d␈↓FROM,␈α∂selects␈α∂the␈α∂winner.␈α∂ Often,␈α∂as␈α∂in␈α∂the␈α∂first␈α∞case␈α∂for␈α∂this␈α∂BEING,␈α∂the␈α∂program␈α∂which␈α∂is␈α∂returned␈α∞calls
␈↓ d␈↓TRANSLATE recursively on some parts of ␈↓βF␈↓.


␈↓"	␈↓ d␈↓α␈↓↓EXPLICIT-ARGS␈↓α        What arguments do you take?            ␈↓↓The single argument U␈↓α.      (U)
␈↓"/␈↓ d␈↓The␈αargument␈αto␈αthis␈αBEING␈α
is␈αnever␈αoperated␈αupon,␈αhence␈αthere␈α
is␈αno␈αneed␈αto␈αunderstand␈αanything␈α
about␈αit.
␈↓ d␈↓It is simply passed to BEINGs called by OBTAIN-USABLE-INFORMATION.


␈↓"	␈↓ d␈↓α␈↓↓WHAT␈↓α         Basically, what do you do?     ␈↓↓I obtain some information which can be used.␈↓α
␈↓"	␈↓ d␈↓α␈↓↓HOW␈↓α          How do you do this?            ␈↓↓Either obtain new facts about old information, or
␈↓"	␈↓ d␈↓↓                                                else obtain totally new information.␈↓α
␈↓"	␈↓ d␈↓α␈↓↓WHY␈↓α          Why do you do this?            ␈↓↓PUP6 has no more information that is immediately usable␈↓α.
␈↓"/␈↓ d␈↓These␈α∀three␈α∃parts␈α∀are␈α∀primarily␈α∃for␈α∀the␈α∀user's␈α∃benerfit.␈α∀In␈α∀the␈α∃current␈α∀case,␈α∀they␈α∃don't␈α∀even␈α∃have␈α∀any
␈↓ d␈↓uninstantiated␈α
parts.␈α
 If␈α
the␈α
user␈α
asks␈α
one␈α
of␈α
these␈α
questions␈α
when␈α
this␈α
BEING␈α
is␈α
in␈α
control,␈α
then␈αthe␈α
appropriate
␈↓ d␈↓answer can simply be typed out.
␈↓ d␈↓α␈↓↓WHEN␈↓α         How badly do you want control now, and why?      ␈↓↓Overa ll rating is high
␈↓"	␈↓ d␈↓↓                                        because there are 5 pieces of new information.␈↓α
␈↓"	␈↓ d␈↓α((if T then add in -10 because (THIS IS AN EXPONENTIALLY-GROWING, BAD THING TO DO IN GENERAL))
␈↓"	␈↓ d␈↓α (if NEW-INFO-LIST then add in  (PLUS  100  (LENGTH  NEW-INFO-LIST))
␈↓"	␈↓ d␈↓α                because (WE SHOULD WORK ON UNASSIMILATED NEW  INFORMATION IF THERE IS ANY)))
␈↓"/␈↓ d␈↓The␈α
WHEN␈α∞part␈α
of␈α
a␈α∞BEING␈α
is␈α
a␈α∞collection␈α
of␈α
triples:␈α∞if␈α
<predicate>␈α
then␈α∞<value>␈α
because␈α
<reason>.␈α∞ If␈α
the
␈↓ d␈↓<predicate>␈α∞evaluates␈α∞to␈α∂non-null,␈α∞then␈α∞the␈α∂<value>␈α∞program␈α∞is␈α∂executed.␈α∞It␈α∞returns␈α∂a␈α∞number,␈α∞which␈α∂is␈α∞then
␈↓ d␈↓added␈αtogether␈αwith␈αthe␈αother␈αfactors'␈αnumbers␈αto␈αproduce␈αa␈αrough␈αestimate␈αof␈αhow␈αa␈αpropos␈αthis␈αBEING␈αis␈αto
␈↓ d␈↓take␈αcontrol␈αright␈αnow.␈α The␈α<reason>␈αevaluates␈αto␈αan␈αEnglish␈αphrase,␈αfor␈αthe␈αbenefit␈αof␈αinquisitive␈αusers.␈α This
␈↓ d␈↓linear␈αscheme␈α
is␈αundesirable␈αbut␈α
(sigh)␈αadequate.␈αThe␈α
first␈αfactor␈α
here␈αsays␈αto␈α
always␈αadd␈αin␈α
the␈αnumber␈α-10;␈α
the
␈↓ d␈↓second␈αsays␈αif␈αthere␈αis␈αsome␈αnew␈αinformation␈αsitting␈αaround␈αunexploited,␈αto␈αadd␈αin␈α100␈αplus␈αthe␈αnumber␈αof␈αsuch
␈↓ d␈↓pieces.␈α
 These␈αfactors␈α
and␈αtheir␈α
weights,␈αlike␈α
the␈αcontents␈α
of␈αall␈α
the␈αparts␈α
of␈αall␈α
the␈αBEINGs␈α
initially␈α
in␈αPUP6,
␈↓ d␈↓were decided upon and inserted by hand.


␈↓"	␈↓ d␈↓α␈↓↓META-CODE␈↓α      What do you do specifically to achieve your results?         ␈↓↓Have four
␈↓"	␈↓ d␈↓↓                specific BEINGs decide among themselves who goes next.␈↓α
␈↓"	␈↓ d␈↓α(DO
␈↓"	␈↓ d␈↓α         (CHOOSE-FROM (GET-NEW-INFORMATION U)
␈↓"	␈↓ d␈↓α                       (TRANSLATE U)
␈↓"	␈↓ d␈↓α                       (ANALYZE-IMPLICATIONS U)
␈↓"	␈↓ d␈↓α                       (EXTRACT-RELEVANT-SUBSET U))
␈↓"	␈↓ d␈↓α   BECAUSE
␈↓"	␈↓ d␈↓α         (WE CAN ONLY TRY TO OBTAIN USABLE INFORMATION IN ONE WAY AT A TIME))
␈↓"/␈↓ d␈↓The␈α  META-CODE␈α
 says␈α to␈α
 choose␈α from␈α
 the␈α following␈α
 four␈αalternatives,␈α
   each␈α   of␈α
   which␈α   is␈α
   itself
␈↓ d␈↓a␈α∂    BEING:␈α∂Get-Brand-New-Information␈α∂ (in␈α∂ English,␈α∞ from␈α∂ the␈α∂ user),␈α∂Translate␈α∂something␈α∞   (transform
␈↓ d␈↓from␈α∂    English␈α∂    to␈α∂    BEING-calls),␈α∂Analyze-The-Implications␈α∂ (of␈α∂some␈α∂existing,␈α∂translated␈α∂information),
␈↓ d␈↓Extract-a-Relevant-Subset␈α⊃  (of␈α⊃  the␈α⊃  existing␈α⊃  information)␈α⊃   to␈α⊃concentrate␈α⊃upon.␈α⊃ The␈α⊃goal␈α⊃mechanism,
␈↓ d␈↓SATISFY,␈αis␈αusually␈αemployed␈αwhen␈αthe␈αBEING␈αdoesn't␈αknow␈αexactly␈αwhich␈αother␈αBEINGs␈αto␈αcall.␈αIf␈αthe␈α␈↓βset␈↓␈αof
␈↓ d␈↓possible choices is known, as in this case, then CHOOSE-FROM may be called with the explicit choice set.


␈↓"	␈↓ d␈↓α␈↓↓MAIN-EFFECTS␈↓α         Are you relevant to making the user aware of the time?         ␈↓↓No.␈↓α
␈↓"	␈↓ d␈↓α ((to get (NEW INFO any1)     do (OBTAIN-USABLE-INFORMATION any1))
␈↓"	␈↓ d␈↓α  (to get (USABLE INFO any1)  do (OBTAIN-USABLE-INFORMATION any1)))
␈↓"/␈↓ d␈↓The␈α∃EFFECTS␈α∃parts␈α∃of␈α∃each␈α∃BEING␈α∃are␈α⊗collected␈α∃ into␈α∃one␈α∃ table␈α∃ to␈α∃ facilitate␈α∃ asking␈α⊗all␈α∃BEINGs
␈↓ d␈↓simultaneously␈α
"Can␈αyou␈α
cause␈α
effect␈αX␈α
to␈α
occur?"␈αEach␈α
EFFECTS␈α
part␈αexamines␈α
X␈α
and␈α the␈α
 world,␈α and␈α
either
␈↓ d␈↓replies␈α∞No,␈α
or␈α∞else␈α
returns␈α∞a␈α
little␈α∞program␈α∞(involving␈α
calls␈α∞and␈α
constants)␈α∞which␈α
 should␈α∞ produce␈α∞ the␈α
 effect.
␈↓ d␈↓This program generally will involve a call to the BEING itself. OBTAIN-USABLE-INFORMATION shows
␈↓ d␈↓that it should be called to acheive the existence of new or usable information.


␈↓"	␈↓ d␈↓α␈↓↓AFFECTS␈↓α             Will you call TRANSLATE?                ␈↓↓Possibly.␈↓α
␈↓"	␈↓ d␈↓α       ( (CHOOSE-FROM IS CALLED)
␈↓"	␈↓ d␈↓α                (TRANSLATE POSSIBLY IS CALLED)
␈↓"	␈↓ d␈↓α                (GET-NEW-INFORMATION POSSIBLY IS CALLED)
␈↓"	␈↓ d␈↓α                (ANALYZE-IMPLICATIONS POSSIBLY IS CALLED)
␈↓"	␈↓ d␈↓α                (EXTRACT-RELEVANT-SUBSET POSSIBLY IS CALLED) )


␈↓"	␈↓ d␈↓α␈↓↓COMPLEXITY-VECTOR␈↓α    How difficult are you to call?         ␈↓↓Average.␈↓α       (.5 .5 .5 .1)
␈↓"/␈↓ d␈↓The␈αfirst␈α
component␈αsays␈αthat␈α
OBTAIN-USABLE-INFORMATION␈αis␈α
of␈αaverage␈αdifficulty␈α
to␈αcall.␈αNext,␈α
there
␈↓ d␈↓exists␈αa␈α.5␈αchance␈αthat␈αsome␈αdescendant␈αwill␈αcall␈α
it␈αagain.␈αThe␈αthird␈αcomponent␈αindicates␈αthat␈αthe␈αcost␈α
of␈αtrying
␈↓ d␈↓this␈αBEING␈αis␈α
typical.␈αFinally,␈αthere␈α
is␈αno␈αgood␈α
reason␈αfor␈αinhibiting␈α
it␈αever.␈α In␈α
general,␈αeach␈αcomponent␈αcan␈α
be
␈↓ d␈↓a ␈↓βprogram␈↓, not just a constant.


␈↓"	␈↓ d␈↓α␈↓↓GENERALIZATIONS␈↓α      What BEINGs are mor e general than you are?    ␈↓↓WRITE-PROGRAM
␈↓"	␈↓ d␈↓↓                        and SERVE-THE-USER␈↓α.           (WRITE-PROGRAM SERVE-THE-USER)
␈↓"	␈↓ d␈↓α␈↓↓ALTERNATIVES␈↓α         In case you fail, who else might I try?        ␈↓↓Try USE-INFORMATION,
␈↓"	␈↓ d␈↓↓                        FIX-INCORRECT-PIECE, OPTIMIZE, or FILL-IN-UNDEFINED-SECTION)␈↓α
␈↓"	␈↓ d␈↓α(USE-INFORMATION FIX-INCORRECT-PIECE OPTIMIZE FILL-IN-UNDEFINED SECTION)
␈↓"/␈↓ d␈↓These␈αlist␈αthings␈αto␈αtry␈αif␈αthis␈αBEING␈αfails␈αin␈αits␈αmission.␈αThe␈αalternatives␈αshould␈αgenerally␈αbe␈αtried␈αbefore␈αthe
␈↓ d␈↓more general BEINGs.
␈↓"/␈↓ d␈↓To␈α⊃illustrate␈α⊂a␈α⊃few␈α⊂of␈α⊃the␈α⊂other␈α⊃BEING␈α⊂parts,␈α⊃consider␈α⊂PARTITION-A-DOMAIN,␈α⊃a␈α⊃high-level,␈α⊂domain-
␈↓ d␈↓specific␈αBEING.␈α Its␈αbasic␈αidea␈αis␈αto␈αdivide␈α
up␈αa␈αspace␈αinto␈α categories.␈α Only␈α two␈αBEING␈α  parts␈α
  are␈α  filled
␈↓ d␈↓in␈α∪  here␈α∪  which␈α∪  were␈α∪ absent␈α∪ from␈α∪OBTAIN-USABLE-INFORMATION:␈α∀ SPECIALIZATIONS␈α∪ and
␈↓ d␈↓DEMONS.
␈↓"/␈↓ d␈↓The␈αSPECIALIZATIONS␈αpart␈αsays␈αthat␈αto␈αwrite␈αa␈αspecific␈αversion␈αof␈αitself,␈αa␈αfew␈αdecisions␈αmust␈αbe␈αmade.␈αThe
␈↓ d␈↓results␈α⊃ will␈α⊃ then␈α⊃ indicate␈α⊂ what␈α⊃pieces␈α⊃ of␈α⊃ code␈α⊂ get␈α⊃ assembled␈α⊃together␈α⊃to␈α⊂form␈α⊃the␈α⊃new␈α⊃BEING.␈α⊂ The
␈↓ d␈↓partition␈α
may␈α∞be␈α
only␈α∞partial␈α
(an␈α
element␈α∞of␈α
the␈α∞domain␈α
belongs␈α∞to␈α
no␈α
class␈α∞ of␈α
 the␈α∞partition),␈α
only␈α∞weak␈α
(an
␈↓ d␈↓element␈α
belongs␈αto␈α
more␈α
than␈αone␈α
class),␈α
and,␈αmost␈α
importantly,␈α
the␈αspecialized␈α
partitioning␈α
BEING␈αshould␈α
 work
␈↓ d␈↓by␈α repeatedly␈αdoing␈αsome␈αof␈αthe␈αfollowing␈αthree␈αactivities:␈αaccept␈αa␈αclass-name␈αfrom␈αthe␈αuser␈αand␈αguess␈αsome␈αof
␈↓ d␈↓its␈α
elements,␈α
accept␈α
an␈α
element␈α
from␈αthe␈α
user␈α
and␈α
try␈α
to␈α
guess␈α
which␈αclass␈α
it␈α
belongs␈α
to,␈α
or␈α
accept␈α
an␈α<element,
␈↓ d␈↓class-name> pair. Other BEINGs know about these accepting, guessing, and checking activities.
␈↓ d␈↓The␈α
 DEMONS␈α∞ part␈α
says␈α
that␈α∞during␈α
the␈α∞partitioning,␈α
the␈α
only␈α∞new␈α
demon␈α∞to␈α
keep␈α
active␈α∞is␈α
the␈α∞one␈α
 called
␈↓ d␈↓Fringe-of-Consciousness.␈α∞ This␈α∞deserves␈α∞elaboration.␈α∞In␈α∞ the␈α∞ course␈α∞ of␈α∞writing␈α∞ GI,␈α∞ the␈α∞ system␈α∞ learns␈α∞ that
␈↓ d␈↓the␈α∞ main␈α
 task␈α∞ is␈α
 one␈α∞ of␈α
grammatical␈α∞inference.␈α
 The␈α∞GRAMMAR␈α
BEING␈α∞then␈α
 asserts␈α∞that␈α
 if␈α∞ the␈α
 user
␈↓ d␈↓ever␈αmentions␈αthe␈αword␈αTEST,␈αhe␈αmay␈αactually␈αmean␈αPARSE.␈α  This␈αis␈αplaced␈αin␈αthe␈αIDEN␈αpart␈αof␈αthe␈αTEST
␈↓ d␈↓BEING,␈α
 and␈α
 is␈α
therefore␈α
  only␈α
 demonized,␈α
 waiting␈α
 on␈α
 the␈α
 periphery␈α
 of␈α
 PUP6's␈α
concentration.␈α
  It␈α
is␈αin
␈↓ d␈↓fact triggered later in the dialogue, as an inference surprising to the user.
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α⊗␈↓∧␈↓&6. Control in the system␈↓)αβ␈↓
␈↓"/␈↓ d␈↓The␈α∂BEINGs␈α∞control␈α∂themselves␈α∞in␈α∂a␈α∞simple␈α∂way.␈α∞A␈α∂very␈α∞general␈α∂BEING,␈α∞SERVE-THE-USER,␈α∂has␈α∞control
␈↓ d␈↓initially.␈αIn␈α
general,␈αsome␈α
 BEING␈α␈↓βB␈↓␈α will␈α
 be␈α in␈α
 control.␈α  Its␈αBEING␈α
parts␈αare␈α
assembled␈αinto␈α
an␈αexecutable
␈↓ d␈↓function,␈αand␈αit␈αis␈αrun.␈α During␈αthe␈αcourse␈αof␈αits␈α reign,␈α␈↓βB␈↓␈α will␈α want␈αthings␈αdone␈αand/or␈αtested␈αwhich␈αit␈αcannot
␈↓ d␈↓manage␈αby␈αitself.␈α This␈αcorresponds␈αto␈αwhen␈αa␈αnormal␈αprogram␈αneeds␈α to␈α call␈α a␈αsubroutine.␈α What␈α␈↓βB␈↓␈αdoes␈αis␈αto
␈↓ d␈↓provide␈α⊃SATISFY,␈α⊃the␈α⊃goal␈α∩mechanism,␈α⊃with␈α⊃a␈α⊃description␈α⊃of␈α∩what␈α⊃is␈α⊃wanted.␈α⊃ SATISFY␈α⊃asks␈α∩ the␈α⊃entire
␈↓ d␈↓BEING␈α pool␈α "who␈αcan␈αdo␈αthis␈αthing?",␈αand␈αcollects␈αa␈αlist␈αof␈αthe␈αresponders.␈α CHOOSE-FROM␈αis␈αthen␈αcalled,
␈↓ d␈↓and␈αasks␈αeach␈αresponder␈αwhy␈αhe␈αshould␈αbe␈αallowed␈αto␈αgo␈αnow␈α(the␈αWHEN␈αpart␈αanswers␈αthis)␈αand␈αhow␈αcostly␈αhe
␈↓ d␈↓will␈α∞be␈α∞if␈α∞he␈α∞does␈α∞go␈α∞(the␈α∞COMPLEXITY␈α∞part).␈α∞The␈α∞responders␈α∞are␈α∞then␈α∞passed␈α∞control,␈α∞in␈α∞order,␈α∞until␈α
one
␈↓ d␈↓succeeds␈αor␈αall␈αhave␈α
failed.␈α In␈αaddition␈αto␈α
these␈αgoal␈α statements,␈α there␈α
 exists␈α a␈α"world"␈αconsisting␈αof␈α
assertions
␈↓ d␈↓and␈α∞variables␈α∞with␈α∞values.␈α∞These␈α∞are␈α∞regarded␈α∞as␈α∂trivial␈α∞cases␈α∞of␈α∞BEINGs,␈α∞possessing␈α∞only␈α∞ one␈α∞ part.␈α∂  So␈α∞␈↓βB␈↓
␈↓ d␈↓may␈αalso␈αquery␈αthis␈αdata␈αbase␈αby␈αsaying␈α"what␈αassertions␈α
match␈αthis␈αone...",␈αor␈αby␈αasking␈α"what␈αis␈αthe␈αvalue␈α
of...".
␈↓ d␈↓These␈α∂ actions␈α∂can␈α∂be␈α∞programmed␈α∂in␈α∂a␈α∂much␈α∞more␈α∂efficient␈α∂manner␈α∂than␈α∞as␈α∂BEINGs.␈α∂ They␈α∂never␈α∞employ
␈↓ d␈↓nondeterministic␈α
transfers,␈α
hence␈α∞are␈α
faster␈α
by␈α∞an␈α
amount␈α
proportional␈α∞to␈α
the␈α
total␈α∞number␈α
of␈α
BEINGs␈α∞in␈α
the
␈↓ d␈↓system.
␈↓"/␈↓ d␈↓The␈α
way␈α
a␈α
BEING's␈α
parts␈α
fit␈α
together␈α
is␈α
uniform␈αover␈α
all␈α
the␈α
BEINGs␈α
at␈α
all␈α
times.␈α
Thus␈α
one␈α
simple␈αfunction␈α
(an
␈↓ d␈↓assembled␈α
BEING)␈α
assembles␈α
all␈αthe␈α
BEINGs␈α
initially␈α
into␈α
LISP␈αfunctions.␈α
 The␈α
precise␈α
algorithm␈α
for␈αdoing␈α
this
␈↓ d␈↓is␈αnow␈αdiscussed.␈α First,␈αthe␈α
explicit␈αarguments␈α(those␈αglobal␈αto␈α
the␈αBEING)␈α are␈α bound.␈αThe␈αimplicit␈α
arguments
␈↓ d␈↓(those␈αlocal␈αto␈α
the␈αBEING,␈αlike␈αPROG␈α
variables)␈αare␈αinitialized.␈α
The␈αname␈αof␈αthe␈α
BEING␈αis␈αpushed␈α
onto␈α the
␈↓ d␈↓BEING␈α control␈α stack,␈α
and␈αany␈αnewly-activated␈α
 demons␈α are␈α pushed␈α onto␈α
 the␈α demon␈α stack.␈α
  The␈αARGS-
␈↓ d␈↓CHECK␈α∞ predicates␈α∞ are␈α∂ evaluated.␈α∞ Then␈α∞PUP6␈α∂works␈α∞to␈α∞make␈α∞each␈α∂PRE-REQUISITE␈α∞true␈α∞in␈α∂the␈α∞world.
␈↓ d␈↓Each␈α∞COMMENT␈α∞is␈α∞evaluated,␈α
then␈α∞the␈α∞CO-REQUISITES,␈α∞ META-CODE,␈α
 and␈α∞ current␈α∞ demons␈α∞ all␈α
are
␈↓ d␈↓executed␈α
in␈αpseudo-parallel.␈α
 Each␈α
POST-REQUISITE␈αis␈α
then␈αsatisfied.␈α
 These␈α
activities␈αare␈α
all␈α
embedded␈αin
␈↓ d␈↓an␈α
AND,␈α
so␈α
any␈α
of␈αthem␈α
can␈α
cause␈α
the␈α
entire␈αBEING␈α
to␈α
halt␈α
and␈α
fail,␈αsimply␈α
by␈α
returning␈α
NIL.␈α
 Just␈α before
␈↓ d␈↓exiting,␈α⊂ the␈α∂ demon␈α⊂and␈α∂BEING␈α⊂stacks␈α∂are␈α⊂ popped,␈α∂and␈α⊂control␈α∂passes␈α⊂to␈α∂the␈α⊂delegated␈α∂BEING.␈α⊂ A␈α∂fancy
␈↓ d␈↓context mechanism was available but not actually needed.
␈↓ d␈↓The␈α
function␈α
which␈α
assembled␈α
all␈α
the␈α
BEINGs␈α
exploited␈α
the␈α
fact␈α
that␈α
it␈α
operated␈α
only␈α
at␈α
 system␈α
load␈αtime.␈α
Thus
␈↓ d␈↓if␈α∂the␈α∞BEING␈α∂had␈α∞no␈α∂new␈α∞DEMONs␈α∂to␈α∞activate,␈α∂all␈α∞the␈α∂corresponding␈α∞demon-stack␈α∂manipulations␈α∂could␈α∞be
␈↓ d␈↓omitted.␈α∂Similarly,␈α∂no␈α∞CO-REQUISITES␈α∂means␈α∂no␈α∞parallel␈α∂processing␈α∂need␈α∞be␈α∂simulated.␈α∂Optimizations␈α∞like
␈↓ d␈↓these␈α⊗are␈α⊗clear␈α⊗from␈α⊗comparing␈α↔the␈α⊗parts␈α⊗of␈α⊗OBTAIN-USABLE-INFORMATION,␈α⊗the␈α↔algorithm␈α⊗just
␈↓ d␈↓described, and the actual functional version produced:

␈↓"	␈↓ d␈↓α(OBTAIN:USABLE:INFORMATION
␈↓"	␈↓ d␈↓α  (LAMBDA (U)
␈↓"	␈↓ d␈↓α     (AND
␈↓"	␈↓ d␈↓α         (SETQ BEING:STACK (CONS OBTAIN:USABLE:INFORMATION BEING:STACK))
␈↓"	␈↓ d␈↓α         (PUT OBTAIN:USABLE:INFORMATION SPEC:WHY BECAUSE)
␈↓"	␈↓ d␈↓α         (EVERY    (APPEND CURRENT:DEMONS USER:INTERRUPT:DEMONS)    (QUOTE APPLY*))
␈↓"	␈↓ d␈↓α         (SETQQ BECAUSE
␈↓"	␈↓ d␈↓α                 (WE CAN ONLY TRY TO OBTAIN USABLE INFORMATION IN ONE WAY AT A TIME))
␈↓"	␈↓ d␈↓α         (CHOOSE:FROM
␈↓"	␈↓ d␈↓α                 (GET:NEW:INFORMATION U)
␈↓"	␈↓ d␈↓α                 (TRANSLATE U)
␈↓"	␈↓ d␈↓α                 (ANALYZE:IMPLICATIONS U)
␈↓"	␈↓ d␈↓α                 (EXTRACT:RELEVANT:SUBSET U))))
␈↓"	␈↓ d␈↓α         (SETQ BEING:STACK (CDR BEING:STACK))))
␈↓"/␈↓ d␈↓Each␈α∞BEING␈α∂has␈α∞the␈α∂responsibility␈α∞to␈α∞set␈α∂the␈α∞value␈α∂of␈α∞the␈α∞variable␈α∂BECAUSE␈α∞just␈α∂prior␈α∞to␈α∂calling␈α∞another
␈↓ d␈↓BEING.␈α⊃When␈α⊃a␈α⊂BEING␈α⊃takes␈α⊃control,␈α⊂it␈α⊃immediately␈α⊃stores␈α⊂the␈α⊃current␈α⊃value␈α⊂of␈α⊃BECAUSE␈α⊃as␈α⊃a␈α⊂special
␈↓ d␈↓addition␈αto␈αits␈αWHY␈αpart.␈αThus␈αeach␈αBEING␈αcan␈αprovide␈αtwo␈αreasons:␈αone␈αsupplied␈αin␈αgeneral,␈αand␈αone␈αset␈αby
␈↓ d␈↓the␈α
particular␈α
BEING␈α
which␈αcalls␈α
it.␈α
Above,␈α
notice␈αhow␈α
OBTAIN-USABLE-INFORMATION␈α
sets␈α
a␈αreason␈α
for
␈↓ d␈↓calling CHOOSE-FROM.
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α↔␈↓∧␈↓&7. Theoretical aspects of PUP6␈↓)αβ␈↓
␈↓"/␈↓ d␈↓For␈αaesthetic␈αreasons,␈αan␈αeffort␈αwas␈αmade␈αto␈αkeep␈αthe␈αlanguages␈αfor␈αPUP6␈αand␈αCF␈αthe␈αsame.␈αThis␈αmeant␈αPUP6
␈↓ d␈↓must␈αwrite␈αCF␈αas␈αa␈αfamily␈αof␈αBEINGs.␈α Consequently␈α␈↓βsome␈↓␈αBEING(s)␈αmust␈αwrite␈αnew␈αBEINGs.␈αThe␈αsignificant
␈↓ d␈↓design␈α
issue␈α
here␈α
is␈α
that␈α
the␈α
BEING␈α
 who␈α
 knows␈α
 about␈α
␈↓βX␈↓␈α
 takes␈α
 charge␈α
 of␈α
 generating␈α
 new␈αBEINGs␈α
 relating
␈↓ d␈↓to␈α
␈↓βX␈↓.␈α
 For␈α
example,␈α∞ the␈α
 INSERT␈α
 BEING␈α
 can␈α∞ do␈α
 inserting␈α
 by␈α
 one␈α
 of␈α∞ a␈α
 few␈α
algorithms,␈α
 and␈α∞ he␈α
 can
␈↓ d␈↓also␈α∂ write␈α⊂(by␈α∂specializing␈α∂himself)␈α⊂more␈α∂specific␈α∂ insert␈α⊂ routines,␈α∂ and␈α∂ he␈α⊂ can␈α∂ answer␈α⊂  questions␈α∂  about
␈↓ d␈↓inserting.␈α
This␈α
idea␈α
is␈α∞analogous␈α
to␈α
any␈α
reliance␈α∞upon␈α
experts.␈α
The␈α
SPECIALIZATIONS␈α∞and␈α
ENCODABLE
␈↓ d␈↓parts handle this chore.
␈↓"/␈↓ d␈↓An␈α∂unusual␈α⊂consequence␈α∂is␈α⊂that␈α∂the␈α∂synthesized␈α⊂code␈α∂ will␈α⊂ have␈α∂ all␈α∂the␈α⊂␈↓βtypes␈↓␈α∂of␈α⊂abilities␈α∂that␈α⊂any␈α∂BEING
␈↓ d␈↓community␈αhas:␈α     it␈αcan␈αwrite␈α
variations␈αof␈αitself,␈αmodify␈αitself␈α
according␈αto␈αthe␈αuser's␈αcomplaints,␈α and␈α
 answer
␈↓ d␈↓questions␈α⊃about␈α⊃what␈α⊃it␈α∩is␈α⊃doing␈α⊃as␈α⊃it␈α∩runs.␈α⊃ The␈α⊃CF␈α⊃program␈α⊃generated␈α∩cannot,␈α⊃of␈α⊃course,␈α⊃write␈α∩the␈α⊃full
␈↓ d␈↓complement  of programs PUP6 could write.
␈↓"/␈↓ d␈↓In␈αa␈αsimilar␈αvein,␈αrecall␈αthat␈α␈↓βeach␈↓␈αBEING␈αmust␈αdo␈αthe␈α translation␈αof␈α the␈α users'␈αrelevant␈α
quasi-English␈αinputs
␈↓ d␈↓into␈α⊂BEING-usable␈α⊂form.␈α⊃For␈α⊂example,␈α⊂our␈α⊃ INSERT␈α⊂ BEING␈α⊂ must␈α⊃ also␈α⊂ recognize␈α⊂ and␈α⊃process␈α⊂phrases
␈↓ d␈↓involving inserting, stack-pushing, and merging.
␈↓"/␈↓ d␈↓PUP6␈α⊃does␈α⊃not␈α⊃operate␈α⊃within␈α⊃the␈α⊃exploratory␈α⊃anthropomorphic␈α⊃paradigm␈α⊃of␈α⊃programming␈α⊃(ignore␈α⊃details,
␈↓ d␈↓catch␈α them␈αlater␈αby␈αdebugging).␈α
 As␈αin␈αall␈αprogramming,␈αdecisions␈αcontinually␈α
crop␈αup␈αwhich␈αthe␈αsystem␈α
is␈αnot
␈↓ d␈↓able␈α∞to␈α∂resolve␈α∞ at␈α∞ the␈α∂ time.␈α∞PUP6␈α∞always␈α∂tries␈α∞to␈α∞defer␈α∂the␈α∞decision␈α∞as␈α∂long␈α∞as␈α∞possible.␈α∂ When,␈α∞at␈α∂last,␈α∞no
␈↓ d␈↓progress␈α∞can␈α
be␈α∞made␈α
without␈α∞its␈α
resolution,␈α∞ and␈α
 if␈α∞the␈α
system␈α∞is␈α
still␈α∞unsure,␈α
then␈α∞either␈α
the␈α∞user␈α∞settles␈α
the
␈↓ d␈↓question␈α
or␈α
else␈α
a␈α
backtrack␈α
point␈α
is␈α
reluctantly␈α
set␈α
up.␈α
 But␈α
 often,␈α
 by␈α
 this␈α
 time,␈α
 some␈α
 new␈α
 information␈α
is
␈↓ d␈↓present␈αwhich␈αenables␈αthe␈αsystem␈αto␈αresolve␈αthe␈αdecision,␈αthus␈αreducing␈αthe␈α amount␈αof␈α backtracking.␈α  If␈α there
␈↓ d␈↓are two or more decisions which can no longer be deferred, the system tackles the easiest one first.
␈↓"/␈↓ d␈↓It␈α
was␈α∞hoped␈α
that␈α∞most␈α
of␈α∞the␈α
 carelessness␈α
bugs␈α∞could␈α
be␈α∞eliminated␈α
through␈α∞this␈α
deferral,␈α∞feed-forward,␈α
and
␈↓ d␈↓very␈α
precise␈α
 record-keeping.␈α
 Humans␈α
 depend␈α
 on␈α
 their␈α
 adaptability␈α
 to␈α
compensate␈α
 for␈α
limitations␈α
in␈αtheir
␈↓ d␈↓brain␈αhardware␈α[8]␈αbut␈αthere␈αis␈αno␈αneed␈αfor␈αan␈α␈↓βautomatic␈↓␈αprogramming␈αsystem␈αto␈αdo␈αso.␈α For␈α example,␈αwhen␈α a
␈↓ d␈↓list␈α structure␈α is␈α first␈α encountered,␈α the␈αsystem␈αrecords␈αwarnings␈αthat␈αit␈αis␈αundefined,␈αno␈αaccesses,␈αinsertions,␈αor
␈↓ d␈↓deletions␈αhave␈α been␈α observed,␈α and␈α so␈α on.␈α Each␈αsuch␈αworry␈αis␈αweighted,␈αand␈αperiodically␈αthe␈αsystem␈αresolves
␈↓ d␈↓such  warning  notes  --  especially near the completion of the target program.
␈↓"/␈↓ d␈↓The␈α new␈α BEINGs␈α created␈αduring␈α the␈α execution␈αof␈αa␈αspecified␈αtask␈αare␈αkept␈αdistinct␈αfrom␈αthe␈αoriginal␈αset␈α of
␈↓ d␈↓BEINGs.␈αA␈α␈↓βprogram␈↓␈α for␈α task␈α ␈↓βT␈↓␈α is␈αaccomplished␈α by␈αdoing␈α␈↓βT␈↓␈αand␈αthen␈αdumping␈αthe␈αnew␈αBEINGs␈αout␈αonto␈αa
␈↓ d␈↓new␈αfile.␈α The␈αentire␈αold␈α BEINGs␈α pool␈α is␈α then␈α treated␈α as␈α the␈αlanguage␈α supporting␈αthis␈αfile.␈αAs␈αa␈αcorollary,
␈↓ d␈↓asking a BEINGs-based system to write any subset of itself is the null task.
␈↓"/␈↓ d␈↓Most␈α programmers␈α intentionally␈αaugment␈αtheir␈αcode␈αto␈αaid␈αin␈αlater␈αdebugging,␈αmodification,␈αand␈αreadability␈αby
␈↓ d␈↓humans.␈α⊗ These␈α∃aids␈α⊗are␈α⊗ typically␈α∃ comments,␈α⊗ summaries,␈α∃ over-generalized␈α⊗ subroutines,␈α⊗optional␈α∃print
␈↓ d␈↓statements,␈α
 and␈α
 runtime␈α
 statistics.␈α
 Recently,␈α
the␈α
structure␈α
 of␈α
 the␈α
 program␈α
 itself␈α
has␈α
also␈α
been␈α
recognized␈αas␈α
a
␈↓ d␈↓powerful␈α
manipulable␈α
element,␈α
affecting␈α
the␈αaccessability␈α
of␈α
the␈α
code,␈α
not␈αjust␈α
its␈α
length␈α
or␈α
running␈α
time.␈α The
␈↓ d␈↓length␈α
of␈α
any␈α
program␈α
written␈α
as␈α
a␈α
pool␈α
 of␈α∞BEINGs␈α
 is␈α
several␈α
times␈α
as␈α
long␈α
as␈α
a␈α
clean␈α∞hand-coded␈α
version.
␈↓ d␈↓This␈α⊃extra␈α⊃code,␈α⊃the␈α⊃parts␈α⊃of␈α⊃each␈α⊃new␈α⊂BEING␈α⊃which␈α⊃are␈α⊃superfluous,␈α⊃may␈α⊃be␈α⊃viewed␈α⊃as␈α⊃organized␈α⊂self-
␈↓ d␈↓documentation.␈α
 They␈α∞should␈α
in␈α∞theory␈α
improve␈α∞the␈α
debugging,␈α∞expansion,␈α
and␈α∞ accessibility␈α
 (to␈α∞ alien␈α
 users)
␈↓ d␈↓of  the synthesized code.
␈↓"/␈↓ d␈↓Some␈α
assertions␈αare␈α
so␈α
meaningful␈α to␈α
 the␈α
 user,␈αthat␈α
they␈α
should␈αbe␈α
stored␈α
in␈αthe␈α
code␈α
itself,␈αeven␈α
if␈α
they␈αare
␈↓ d␈↓only␈αtemporary.␈α At␈αany␈αtime,␈α
the␈αuser␈αmay␈αlook␈αat␈α
a␈αpiece␈αof␈αcode;␈αthe␈α
comments␈αpresent␈α ␈↓βthen␈↓␈αare␈α all␈α
assertions
␈↓ d␈↓pertaining␈αto␈αthat␈αpiece␈αof␈αcode␈αat␈αthat␈αtime.␈α BEINGS␈αmay␈αuse␈αcomments␈αat␈α several␈α different␈α levels.␈α At␈α the
␈↓ d␈↓lowest␈α∩ level,␈α∩ each␈α∩ comment␈α∩ is␈α∩ merely␈α∩ a␈α∩ unique␈α⊃token;␈α∩it␈α∩may␈α∩be␈α∩inserted,␈α∩removed,␈α∩or␈α∩searched␈α⊃ for.
␈↓ d␈↓Slightly␈α better,␈α the␈α BEINGs␈αsystem␈αcan␈αask␈α"is␈αthere␈αa␈αcomment␈αinvolving␈α...".␈αFor␈αthis␈αpurpose,␈αa␈αconstrained
␈↓ d␈↓syntax␈α
for␈αthe␈α
comments␈α
should␈αbe␈α
developed.␈αOtherwise␈α
(as,␈α
unfortunately␈αin␈α
PUP6)␈αeach␈α
new␈α
comment␈αmust
␈↓ d␈↓be attended to ad hoc.
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α∂␈↓∧␈↓&8. Ideal and real systems␈↓)αβ␈↓
␈↓"/␈↓ d␈↓When␈αimagining␈αan␈αideal␈αAP␈α (automatic␈α programming)␈α system,␈αone␈α ability␈α we␈α might␈α wish␈α for␈α is␈α that␈α it
␈↓ d␈↓be␈α able␈αto␈αinput␈αa␈αwell-documented␈αprogram,␈αglean␈αpure␈αprogramming␈αknowledge␈αfrom␈αit,␈αand␈α transform␈α this
␈↓ d␈↓into␈α a␈α format␈α it␈α can␈αuse.␈α Also,␈αto␈αimprove␈αitself,␈α
it␈αshould␈αbe␈αcapable␈αof␈αdigesting␈αa␈αsample,␈αvalid␈αAP␈α
 dialog,
␈↓ d␈↓and␈α∩(perhaps␈α∩through␈α∩additional␈α∩user␈α∩interaction)␈α∩modify␈α∪itself␈α∩so␈α∩it␈α∩could␈α∩actually␈α∩carry␈α∩on␈α∪that␈α∩ dialog.
␈↓ d␈↓Another␈αideal␈αto␈αhope␈αfor␈αis␈αthat␈αthe␈αuser␈αbe␈αpermitted␈αto␈αdo␈αwhatever␈αhe␈αcan␈αwhenever␈αhe␈αcan;␈αif␈αhe␈αsuddenly
␈↓ d␈↓thinks␈α
of␈α
a␈α
stray␈α
caution,␈α
the␈α
AP␈αsystem␈α
should␈α
accept␈α
it␈α
(e.g.,␈α
"Oh,␈α
I␈αmight␈α
want␈α
to␈α
type␈α
in␈α
HALT␈α
instead␈αof
␈↓ d␈↓STOP,␈α∂sometimes").␈α⊂ BEINGs␈α∂were␈α⊂not␈α∂designed␈α⊂with␈α∂these␈α⊂goals␈α∂in␈α∂mind,␈α⊂and␈α∂as␈α⊂a␈α∂result␈α⊂they␈α∂may␈α⊂be␈α∂an
␈↓ d␈↓insufficient␈α∞framework␈α∞for␈α∞achieving␈α∞them.␈α∞ By␈α∞studying␈α∞the␈α∞difficulties␈α∞of␈α∞PUP6,␈α∞isolating␈α∞those␈α∞due␈α∞to␈α
poor
␈↓ d␈↓programming␈αfrom␈αthose␈α
due␈αto␈αpoor␈α
ideas,␈αenough␈αmay␈α
be␈αlearned␈αto␈α
build␈αthe␈αnext␈α
system␈αone␈αqualitative␈α
step
␈↓ d␈↓closer␈α∞to␈α∞this␈α∞ideal.␈α∞ It␈α∞is␈α∞in␈α∞this␈α∞spirit␈α∞that␈α∞BEINGs␈α∞are␈α∞now␈α∞contrasted␈α∞against␈α∞ the␈α∞ concepts␈α∞ of␈α
 ACTORs,
␈↓ d␈↓CLASSes, FRAMES, HACKER, formal AP systems, and macro expansion schemes.
␈↓"/␈↓ d␈↓ACTORS␈α[5]␈α
 provided␈α the␈α key␈α
 concept␈α of␈α
 integrating␈αuniformity␈α of␈α
 construction␈α with␈α
 sophistocation␈αof
␈↓ d␈↓behavior.␈α∞ Each␈α∞ACTOR␈α∞module␈α∞has␈α∞its␈α∞own,␈α∞unique␈α
parts,␈α∞hence␈α∞must␈α∞be␈α∞(implicitly)␈α∞aware␈α∞of␈α∞all␈α∞the␈α
parts
␈↓ d␈↓(message␈α∂formats)␈α∂of␈α∂all␈α∂the␈α∂ ACTORs␈α∂it␈α∂ever␈α⊂is␈α∂going␈α∂to␈α∂communicate␈α∂with.␈α∂Adding␈α∂a␈α∂new␈α∂module␈α⊂is␈α∂thus
␈↓ d␈↓conceptually␈α
intricate␈α
as␈α
well␈α
as␈α
practically␈α
difficult.␈α
CLASSes␈αhave␈α
a␈α
few␈α
standard␈α
parts,␈α
and␈α
the␈α
modules␈αare
␈↓ d␈↓arranged␈α∂in␈α∂groups,␈α∂each␈α∂of␈α∂which␈α∞has␈α∂its␈α∂own␈α∂additional␈α∂types␈α∂of␈α∞parts.␈α∂Thus␈α∂a␈α∂module␈α∂can␈α∂ask␈α∂␈↓βany␈↓␈α∞other
␈↓ d␈↓module␈α
one␈α
of␈α
a␈α
few␈α
universal␈α
questions,␈α
and␈α
it␈α
can␈α
ask␈α
any␈α
module␈α
in␈α
its␈α
group␈α
an␈α
additional␈α
set␈α
of␈α
questions.␈α
If
␈↓ d␈↓it␈α
is␈α
permitted␈α
to␈α
know␈α
about␈α
other␈α
groups'␈α
special␈αparts,␈α
then␈α
the␈α
same␈α
adding␈α
problem␈α
recurs.␈α
If␈α
it␈α
is␈αdenied
␈↓ d␈↓such␈αknowledge,␈αit␈αcannot␈αaccess␈αmuch␈αof␈αthe␈αknowledge␈αin␈αthe␈αpool.␈α Yet␈αif␈αone␈αrequires␈αa␈αcompletely␈αuniversal
␈↓ d␈↓set␈αof␈αmessage␈α
types,␈αthen␈αmost␈α
of␈αthem␈αwill␈αbe␈α
irrelevant␈αto␈αmost␈α
modules.␈αThis␈αis␈α
the␈αprice␈αwhich␈αBEINGs␈α
pay.
␈↓ d␈↓This superfluity is real and marginally intolerable.
␈↓"/␈↓ d␈↓FRAMES␈α[6]␈αseems␈αsuperficially␈αsimilar␈α to␈α BEINGs,␈α and␈αare␈αso␈αamorphous␈αthat␈αthey␈αactually␈αcould␈αsubsume
␈↓ d␈↓BEINGs.␈α∂There␈α∂is␈α∂a␈α∞deep␈α∂difference␈α∂of␈α∂philosophy␈α∂and␈α∞of␈α∂intended␈α∂usage,␈α∂however.␈α∂ FRAMES␈α∞intentionally
␈↓ d␈↓have␈α
default␈α
values␈α∞already␈α
(with␈α
no␈α∞processing)␈α
filled␈α
in␈α∞ for␈α
each␈α
frame,␈α∞and␈α
replaced␈α
only␈α∞when␈α
 necessary.
␈↓ d␈↓This␈α is␈α akin␈α to␈α automatic␈α programming␈αby␈α
blind␈αdebugging,␈αbut␈αis␈αantithetical␈αto␈αthe␈αfastidious␈α
bookkeeping
␈↓ d␈↓BEINGs␈α
philosophy.␈α As␈α
 an␈α
example,␈α  consider␈α
  the␈α
  writing␈α  of␈α
 a␈α
 short,␈α recursive,␈α
 list␈αmanipulation␈α
LISP
␈↓ d␈↓program␈α∂(reverse,␈α∂flatten,␈α∞assoc,␈α∂alternate,␈α∂ etc.)␈α∞A␈α∂human,␈α∂consulting␈α∞the␈α∂proper␈α∂frame␈α∞in␈α∂his␈α∂head,␈α∂knows␈α∞to
␈↓ d␈↓ignore␈αthe␈αbase␈αstep␈αfor␈αa␈αwhile,␈αthen␈αfill␈αit␈αin,␈αusually␈α as␈α ␈↓βif␈α NIL,␈α then␈αNIL␈↓.␈α The␈αhuman␈αmakes␈αthis␈αdefault
␈↓ d␈↓synthesis,␈α∂tries␈α⊂out␈α∂the␈α∂program,␈α⊂and␈α∂ looks␈α∂closer␈α⊂ (to␈α∂fill␈α∂in␈α⊂this␈α∂"slot"␈α∂properly)␈α⊂only␈α∂if␈α∂something␈α⊂calls␈α∂his
␈↓ d␈↓attention␈αto␈αit␈α(such␈αas␈αa␈αLISP␈αerror␈αmessage:␈αNON-NUMERIC␈αARG␈α ␈↓βNIL␈↓,␈αe.g.,␈αif␈αwhat␈αwas␈αreally␈αneeded␈αwas
␈↓ d␈↓the␈αbase␈αstep␈α␈↓βif␈αNIL,␈αthen␈α0␈↓).␈α A␈αBEINGs␈αsystem␈αwould␈αalso␈α defer␈αworking␈αon␈αthe␈αbase␈αstep,␈αbut␈αcould␈α--␈αand
␈↓ d␈↓would␈α--␈αplace␈αa␈αnote␈αabout␈αthat␈αdeferral␈αinto␈αthe␈αassertional␈αwarning␈αbase.␈α Before␈αthinking␈α it␈α was␈α finished,
␈↓ d␈↓the␈α⊂ system␈α⊃ would␈α⊂ attend␈α⊃to␈α⊂that␈α⊃note␈α⊂carefully.␈α⊃This␈α⊂is␈α⊃not␈α⊂a␈α⊃criticism:␈α⊂  FRAMES␈α⊃are␈α⊂ meant␈α⊃ to␈α⊂model
␈↓ d␈↓perception, BEINGS are not.
␈↓"/␈↓ d␈↓HACKER␈α[9]␈αdiffers␈αfrom␈αPUP6␈αin␈αthe␈αsame␈α qualitative␈αway␈αas␈αFRAMES␈αdo␈αfrom␈αBEINGs.␈α The␈αorientation
␈↓ d␈↓of␈αHACKER␈α
is␈αto␈α
put␈αtogether␈αpieces␈α
of␈αprograms␈α
into␈αsomething␈α
close␈αto␈αthe␈α
final␈αdesired␈α
target,␈αthen␈α try␈α
 and
␈↓ d␈↓run␈α∞it.␈α∞ When␈α∞ errors␈α∞result,␈α∞they␈α∞are␈α∂analyzed␈α∞and␈α∞then␈α∞patched.␈α∞ PUP6␈α∞is␈α∞oriented␈α∞toward␈α∂writing␈α∞bug-free
␈↓ d␈↓code;␈α
what␈α
it␈α
writes␈α
must␈α
 always␈α
coincide␈α
 with␈α
its␈α
internal␈α
specifications␈α
of␈α
that␈α
code.␈α
The␈α
user␈α
may␈αlater␈α
change
␈↓ d␈↓his␈αmind,␈αand␈αthe␈αsystem␈αshould␈αbe␈α(and␈αoccasionally␈αis)␈αable␈αto␈αmodify␈αits␈αown␈α programs,␈α but␈α this␈α process␈α is
␈↓ d␈↓much␈αbetter␈αdefined␈αthan␈αblind␈αdebugging.␈αOn␈αthe␈αother␈α
 hand,␈α if␈α PUP6␈αdoes␈α have␈α an␈αunexpected␈αbug␈αin␈α
it,
␈↓ d␈↓it may be fatal. One way to overcome this would be to include special recover-from-bugs BEINGs.
␈↓"/␈↓ d␈↓The␈α formal␈α manipulation␈α systems␈αwhich␈αalso␈αsynthesize␈αcode␈αare␈αso␈αdifferent␈αfrom␈αBEINGs,␈αthat␈αit␈αis␈αdifficult
␈↓ d␈↓to␈α
 compare␈α
 them.␈α These␈α
 logical␈α
systems␈α
(e.g.,␈αLuckham's)␈α
attack␈α
an␈α
entirely␈αdifferent␈α
problem.␈α
 Their␈α
task␈αis
␈↓ d␈↓specified␈α
rigorously␈α
 in␈α advance,␈α
 and␈α
 they␈α
proceed␈α formally␈α
 to␈α
 search␈α
 for␈α a␈α
 solution␈α
 program.␈α
 PUP6␈αis
␈↓ d␈↓designed␈αto␈αwork␈αon␈αa␈αmuch␈αhigher␈αlevel,␈αheuristically.␈α Each␈α action␈αis␈α implicitly␈αjustified␈αby␈αthe␈αfact␈αthat␈αthe
␈↓ d␈↓user␈α
can␈α
later␈α
describe␈α
to␈αthe␈α
system␈α
what␈α
is␈α
undesirable␈α
about␈αthe␈α
program␈α
it's␈α
generated.␈α
PUP6␈α
 should␈αthus
␈↓ d␈↓be  tolerant of user ambiguity and error.
␈↓"/␈↓ d␈↓Like␈α⊂ ␈↓βany␈↓␈α⊂AP␈α⊂system␈α⊂which␈α⊂writes␈α⊂structured␈α⊂programs,␈α⊂the␈α⊂external␈α⊂behavior␈α⊂ of␈α⊂ PUP6␈α⊂is␈α⊂reminiscent␈α∂ of
␈↓ d␈↓macro␈α
 expansion␈α∞regardless␈α
of␈α∞␈↓βwhat␈↓␈α
the␈α∞internal␈α
BEING␈α∞ interactions␈α
 are.␈α∞ One␈α
 major␈α∞ distinction␈α
 between
␈↓ d␈↓the␈α
 two␈α∞concepts␈α
is␈α∞when␈α
and␈α∞how␈α
the␈α∞macros␈α
are␈α∞expanded.␈α
Traditional␈α∞answers␈α
are:␈α∞ at␈α
 compile␈α∞ time,␈α
 by
␈↓ d␈↓rigid␈α∂  substitutions.␈α∂ BEINGs␈α∂ systems␈α∂expand␈α∂their␈α∂"macros"␈α∂at␈α∂times␈α∂they␈α∂choose,␈α∂using␈α∂knowledge␈α∞gleaned
␈↓ d␈↓from␈α⊂each␈α⊂other␈α⊂ and␈α⊂ from␈α⊂the␈α⊂ user.␈α⊂For␈α⊂example,␈α⊂consider␈α⊂a␈α⊂series␈α⊂of␈α⊂macro␈α⊂calls␈α⊂occurring␈α⊂in␈α⊃the␈α⊂code:
␈↓ d␈↓(m1)(m2)(m3).␈α∪A␈α∪macro␈α∪expander␈α∩could␈α∪expand␈α∪these␈α∪in␈α∩any␈α∪order,␈α∪and␈α∪the␈α∩three␈α∪activities␈α∪could␈α∪go␈α∩on
␈↓ d␈↓simulatneously,␈α
with␈α
no␈α
interference␈αor␈α
change␈α
in␈α
the␈αfinal␈α
code.␈α
BEINGs␈α
would␈α
try␈αto␈α
find␈α
some␈α
task␈αcommon␈α
to
␈↓ d␈↓all␈αthree␈αcalls,␈αand␈αwork␈αon␈αthat␈αfirst.␈αThe␈αorder␈αof␈αwhich␈αto␈αfirst␈αexpand␈αfully␈αwould␈αbe␈αcarefully␈αweighed,␈αand
␈↓ d␈↓during␈α∞that␈α
expansion␈α∞new␈α∞information␈α
would␈α∞be␈α∞learned␈α
which␈α∞could␈α
affect␈α∞the␈α∞expansions␈α
of␈α∞the␈α∞other␈α
two
␈↓ d␈↓function␈αcalls.␈αThe␈αfinal␈αcode␈αwould␈αnot␈αsimply␈αbe␈α
the␈αAPPEND␈αof␈αthe␈αexpansions␈αof␈αm1,␈αm2,␈αm3,␈αas␈α
it␈αwould
␈↓ d␈↓with macro expansion.

␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α/␈↓∧␈↓&9. Questions for AP systems␈↓)αβ␈↓
␈↓"/␈↓ d␈↓The␈αsuccess␈αof␈αan␈αAI␈αeffort␈αcan␈αbe␈αassessed␈αonly␈αwhere␈αaccepted␈αstandards␈αof␈αintelligence␈αexist.␈α The␈α character
␈↓ d␈↓of␈α
the␈α
dialogue␈α(described␈α
in␈α
the␈αnext␈α
section)␈α
is,␈αof␈α
course,␈α
one␈αimportant␈α
measure␈α
of␈αthe␈α
 intelligence␈α
of␈α an␈α
 AP
␈↓ d␈↓system.␈α  One␈αwhich␈αasked␈α"What␈αis␈αthe␈αfirst␈αinstruction?␈α What␈αis␈αthe␈αsecond...?"␈αwould␈αbe␈αuniversal␈αbut␈αworse
␈↓ d␈↓than␈αuseless.␈α This␈α section␈α proposes␈αsome␈α  questions␈α one␈α should␈α ask␈α when␈αconfronted␈αby␈αa␈αnew␈αAP␈αsystem
␈↓ d␈↓which␈α
generates␈αcode␈α
heuristically␈αfrom␈α
a␈αdialogue.␈α
 Capsule␈α
answers␈αpertaining␈α
to␈αPUP6␈α
are␈αparenthesized␈α
after
␈↓ d␈↓each question; fuller answers are located elsewhere.
␈↓"/␈↓ d␈↓The␈αquestions␈αbreak␈αinto␈αtwo␈αcategories.␈αFirst,␈αone␈αwants␈α to␈αknow␈α what␈αthe␈αsystem␈αdoes.␈α Most␈αimportant,␈αdoes
␈↓ d␈↓it␈αsynthesize␈αa␈αprogram?␈α (yes.)␈αIf␈α so,␈α how␈α complex␈α is␈α that␈α task,␈α and␈α what␈α is␈α  the␈α
  program␈αspecification
␈↓ d␈↓like?␈α(a␈α
concept␈αformation␈αprogram,␈α
several␈αpages␈αlong,␈α
from␈αone␈αspecific␈α
protocol␈αdialogue).␈α How␈α
precise␈αmust
␈↓ d␈↓the␈αuser␈αbe:␈α   may␈αhe␈αerr␈α(no),␈αforget␈α(no),␈αchange␈αhis␈αmind?␈α(in␈αlimited␈αcases.)␈αHow␈αdetailed␈αmust␈αhis␈α dialogue
␈↓ d␈↓be?␈α(by␈αconstruction,␈αjust␈αabout␈αas␈αdetailed␈αas␈αif␈αhe␈αwere␈αtalking␈αto␈αa␈αCS␈αgrad␈αstudent␈αprogrammer.)␈αHow␈αclosely
␈↓ d␈↓does␈α the␈α dialogue␈αdetermine␈αthe␈αdetails␈αof␈αthe␈αfinal␈αcode?␈α (much␈αof␈αthe␈αfinal␈αcode␈αis␈αclearly␈αdetermined␈αby␈αthe
␈↓ d␈↓precise␈αuser␈αresponses.)␈αHow␈αdoes␈αthe␈αuser␈αknow␈αwhere␈αhe␈αis␈αduring␈αthe␈αdialogue?␈α(simulated␈αcursors␈αpointing␈αto
␈↓ d␈↓a graph representing synthesized code.)
␈↓"/␈↓ d␈↓Quite␈α seriously,␈αan␈αimportant␈αquestion␈αis␈αwhether␈αthe␈αsystem␈αwrites␈αa␈αsecond␈αprogram.␈α(yes.)␈α If␈αso,␈αhow␈αdoes␈αit
␈↓ d␈↓relate␈α
to␈α
the␈α
first␈α one␈α
synthesized?␈α
(both␈α
are␈αinductive␈α
inference␈α
LISP␈α
programs.)␈α
How␈αmuch␈α
of␈α
the␈α
AP␈αsystem␈α
is
␈↓ d␈↓actually␈αused␈αin␈α
writing␈α␈↓βboth␈↓␈αprograms?␈α(49␈α
BEINGs␈αout␈αof␈α79.)␈α
One␈αshould␈αask␈αwhat␈α
the␈αfull␈αrange␈αof␈α
programs
␈↓ d␈↓is␈α
which␈α
 the␈αsystem␈α
has␈α
successfully␈α
synthesized.␈α(the␈α
concept␈α
former,␈α
the␈αgrammatical␈α
inferrer,␈α
and␈α
the␈αsimple
␈↓ d␈↓property␈αlist␈αmanipulation␈αsystem.)␈αThe␈αdual␈αquestions␈αto␈αthese␈αinquire␈αwhether␈αa␈αprogram␈αmay␈αbe␈αgenerated␈αby
␈↓ d␈↓several␈αdifferent␈α(in␈αthe␈αsense␈αof␈αrephrasing␈αand␈αin␈αthe␈αsense␈αof␈αreordering␈αthe␈αsubtasks)␈αdialogues␈α(theoretically,
␈↓ d␈↓but␈α∞not␈α∞practically),␈α
 and␈α∞ what␈α∞ the␈α∞ range␈α
 of␈α∞variability␈α∞is.␈α∞(theoretically␈α
large,␈α∞but␈α∞practically␈α∞quite␈α
limited.)
␈↓ d␈↓Similarly,␈α
what␈α
about␈α
the␈α
target␈α
language:␈α
is␈α
it␈α
a␈α
parameter?␈α
(no,␈α
always␈α
the␈α
same.)␈α
How␈α
does␈α
it␈α
 relate␈α∞ to␈α
the
␈↓ d␈↓language the system is written in? (both written as BEINGs in INTERLISP.)
␈↓"/␈↓ d␈↓Does␈α∂the␈α∞system␈α∂modify␈α∞as␈α∂well␈α∞as␈α∂write␈α∞code?␈α∂(yes,␈α∂but␈α∞not␈α∂as␈α∞its␈α∂major␈α∞mechanism.)␈α∂  If␈α∞so,␈α∂ can␈α∂it␈α∞ modify
␈↓ d␈↓anybody's,␈α∞ or␈α∞only␈α∞those␈α∞programs␈α∞it␈α∞has␈α∞written␈α∞itself?␈α∂ (only␈α∞its␈α∞own,␈α∞and␈α∞only␈α∞in␈α∞simple␈α∞ways.)␈α∞What␈α∂is␈α∞its
␈↓ d␈↓"style"␈αof␈αprogramming?␈α(many␈αsupplementary␈αcomments,␈αfairly␈αclean␈αstructured␈αprograms␈αonly.)␈αOne␈αalso␈αwishes
␈↓ d␈↓to␈αknow␈αthe␈α size␈αof␈α the␈αtool␈αas␈αwell␈αas␈αthe␈αsize␈αof␈αthe␈αjob:␈αHow␈αdoes␈αthe␈αsystem␈αsize␈αcompare␈αto␈αtarget␈αprogram
␈↓ d␈↓size? (one order of magnitude larger.)
␈↓"/␈↓ d␈↓Efficiency␈α⊃considerations␈α⊂are␈α⊃often␈α⊃the␈α⊂crucial␈α⊃pragmatic␈α⊂ones.␈α⊃Economics␈α⊃and␈α⊂current␈α⊃hardware␈α⊃restrict␈α⊂the
␈↓ d␈↓amount␈α
of␈αcomputation␈α
 which␈α may␈α
be␈αdone␈α
in␈αtoto;␈α
the␈α
expected␈αlifetime␈α
of␈αthe␈α
universe␈αrestricts␈α
us␈αfrom␈α
using
␈↓ d␈↓the␈α most␈α"elegant"␈αalgorithms;␈α and␈αhuman␈α patience␈α restricts␈αthe␈αinteraction␈αdelay␈αtime␈α(to␈αa␈αminute␈αor␈αtwo␈αof
␈↓ d␈↓real␈α
time).␈α
One␈α
must␈α∞therefore␈α
 ask␈α
 things␈α
 like␈α∞how␈α
 much␈α
 time␈α
 and␈α
 space␈α∞ it␈α
 requires,␈α
 how␈α
long␈α∞a␈α
delay
␈↓ d␈↓there␈α∀is␈α∀between␈α∀user␈α∀inputs,␈α∀etc.␈α∀(one␈α∀CPU␈α∀hour,␈α∀100K,␈α∀ ≤1␈α∀CPU␈α∀minute␈α∀between␈α∃responses,␈α∀compiled
␈↓ d␈↓INTERLISP run on a PDP-10 TENEX system.)
␈↓"/␈↓ d␈↓The␈α
 second␈α
 class␈α
of␈α
questions␈α
concerns␈αthe␈α
theoretical␈α
side␈α
of␈α
the␈α
AP␈αsystem.␈α
 What␈α
new␈α
ideas␈α
is␈α
it␈α
meant␈αto
␈↓ d␈↓experiment␈αwith?␈α(using␈αBEINGs␈αto␈αwrite␈αlarge␈αprograms).␈α
 How␈αdo␈αthese␈αideas␈αfare?␈α(mixed␈αresults;␈αthis␈α
is␈αthe
␈↓ d␈↓subject␈α∂of␈α∂most␈α∂of␈α∂the␈α∂remainder␈α∂of␈α∂this␈α∂paper).␈α∂ Does␈α∂it␈α∂write␈α∂its␈α∂code␈α∂in␈α∂the␈α∂right␈α∂way?␈α∂ (it␈α∂asks␈α∂the␈α∞right
␈↓ d␈↓questions␈α
of␈α∞ the␈α
 user␈α
 at␈α∞ just␈α
 the␈α
 proper␈α∞times␈α
with␈α
respect␈α∞to␈α
the␈α
original␈α∞protocol.)␈α
How␈α
extendable␈α∞is␈α
it:
␈↓ d␈↓how␈α∂difficult␈α∂is␈α⊂it␈α∂to␈α∂add␈α∂new␈α⊂pieces␈α∂of␈α∂knowledge␈α⊂and␈α∂to␈α∂modify␈α∂old␈α⊂ones?␈α∂(theoretically␈α∂easy,␈α⊂practically␈α∂it
␈↓ d␈↓requires␈α
familiarity␈α∞with␈α
the␈α∞system.)␈α
 Could␈α∞ it␈α
 write␈α∞ programs␈α
 in␈α∞various␈α
fields␈α∞(possibly),␈α
in␈α∞various␈α
styles
␈↓ d␈↓(unlikely), in various sizes?  (the three target programs differ by less than one order of magnitude.)
␈↓"/␈↓ d␈↓How␈αis␈αknowledge␈α represented␈α internally?␈α(BEINGs,␈αassertions,␈αdemons.)␈α  Is␈α any␈α of␈α it␈αduplicated?␈α(not␈αmuch
␈↓ d␈↓above␈α
the␈αLISP␈α
language␈α
level;␈αsome␈α
universal␈α
knowledge␈αis␈α
factored␈α
out;␈αe.g.,␈α
how␈α
to␈αCHOOSE-FROM␈α
a␈αset␈α
of
␈↓ d␈↓BEINGs.) If so, why? (too primitive to factor it out; e.g., how to bind variables.)
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α$␈↓∧␈↓&10. Examples from the dialogue which results in CF␈↓)αβ␈↓
␈↓"/␈↓ d␈↓The␈αdialogue␈αto␈αsynthesize␈αthe␈αconcept␈αformation␈αprogram␈α(CF)␈αbegins␈αby␈αPUP6␈αasking␈αthe␈αuser␈α for␈α any␈α task.
␈↓ d␈↓The␈α∞user␈α∂replies,␈α∞␈↓βWrite␈α∞a␈α∂program␈α∞which␈α∂does␈α∞concept␈α∞formation␈↓.␈α∂There␈α∞are␈α∞many␈α∂decisions␈α∞that␈α∂PUP6␈α∞knows
␈↓ d␈↓about␈αin␈αwriting␈α a␈α specialized␈α concept␈αformation␈αprogram␈α[4],␈αand␈αit␈αwas␈αgiven␈αjust␈αenough␈αconcept␈αformation
␈↓ d␈↓knowledge␈αto␈αdefer␈α
each.␈α  For␈αexample,␈αit␈α
must␈αchoose␈αbetween␈α
classificatory,␈αcomparative,␈α and␈αmetrical␈α
concept
␈↓ d␈↓formation.␈αSince␈α
all␈αthree␈α
involve␈αpartitioning␈α
a␈αdomain␈αof␈α
examples,␈αPUP6␈α
decides␈α it␈α
 can␈α defer␈α
 this␈αchoice
␈↓ d␈↓until␈α∞ after␈α∞code␈α∞for␈α∞the␈α∞partitioning␈α∞is␈α∞synthesized.␈α∞   The␈α∞effort␈α∞of␈α∞the␈α∞system␈α∞is␈α∞now␈α∞ directed␈α∂ toward␈α∞ this
␈↓ d␈↓"piece"␈α∞ of␈α∂ the␈α∞program.␈α∞ When␈α∂it␈α∞is␈α∞completed,␈α∂an␈α∞hour␈α∞or␈α∂two␈α∞later,␈α∞the␈α∂system␈α∞asks␈α∞the␈α∂user␈α∞to␈α∂make␈α∞this
␈↓ d␈↓decision.␈α∞When␈α∞he␈α∞responds␈α∞ ␈↓βCLASSIFICATORY␈↓,␈α∞which␈α
 involves␈α∞␈↓βonly␈↓␈α∞partitioning,␈α∞ PUP6␈α∞ prints␈α∞that␈α∞it␈α
has
␈↓ d␈↓finished the entire CF task, and dumps the newly created BEINGs  onto a file.
␈↓"/␈↓ d␈↓An␈αexample␈αof␈αthe␈αPUP6␈αcommunity␈αof␈αBEINGs␈αinteracting␈αwill␈αnow␈αbe␈αpresented.␈α When␈αa␈αBEING␈αis␈αsaid␈αto
␈↓ d␈↓do␈αor␈αrecognize␈αor␈αknow␈αsomething,␈αas␈αin␈αthe␈αfollowing␈αparagraphs,␈αwhat␈αis␈αactually␈αmeant␈α is␈αthat␈α one␈αor␈αmore
␈↓ d␈↓of␈α∞its␈α∞parts␈α∞specificly␈α
encode␈α∞that␈α∞knowledge.␈α∞ All␈α∞the␈α
parts␈α∞of␈α∞the␈α∞hundred␈α
BEINGs␈α∞in␈α∞PUP6␈α∞were␈α∞coded␈α
by
␈↓ d␈↓hand,  not  by each  other.  They then  encoded other BEINGs, interacting only via the dialogue.
␈↓"/␈↓ d␈↓Let's␈α
jump␈α
one␈α
third␈α
of␈α
the␈α
way␈α
into␈α
the␈αdialogue␈α
which␈α
writes␈α
 CF.␈α
The␈α
system␈α
learns␈α
it␈α
must␈α
compare␈αthe␈α
input
␈↓ d␈↓scene␈αagainst␈α
its␈αinternally␈αstored␈α
models␈αof␈αconcepts,␈α
until␈αit␈α finds␈α
 one␈α which␈αpasses␈α
the␈α comparison.␈α  It␈α
 asks
␈↓ d␈↓the␈α⊂user␈α⊂what␈α⊂it␈α⊂means␈α⊂for␈α⊂scene␈α⊂S␈α⊂to␈α⊂fail␈α∂the␈α⊂comparison␈α⊂to␈α⊂model␈α⊂M.␈α⊂The␈α⊂user␈α⊂ replies,␈α⊂whenever␈α⊂M␈α∂ is
␈↓ d␈↓incompatible␈α with␈α the␈α observed␈α features␈α of␈α S.␈α The␈αIDEN␈αpart␈αof␈αthe␈αCONTRADICTS␈αBEING␈αrecognizes
␈↓ d␈↓this sentence pattern, and transforms it to
␈↓"/␈↓ d␈↓(FORSOME  F  IN M-FEATURES   (␈↓βspecialized-contradicts␈↓   F   S-FEATURES)).
␈↓"/␈↓ d␈↓The␈αBEING␈αwhich␈αinserts␈αthis␈αinto␈αthe␈αsynthesized␈αcode␈αrequires␈αthat␈α the␈α user␈αpick␈α some␈α proper␈α name␈α for
␈↓ d␈↓the␈α⊂new␈α⊂BEING␈α∂␈↓βspecialized-contradicts␈↓;␈α⊂this␈α⊂will␈α⊂be␈α∂a␈α⊂streamlined␈α⊂contradiction␈α∂test␈α⊂predicate␈α⊂written␈α⊂by␈α∂the
␈↓ d␈↓CONTRADICTS␈αBEING.␈α
 Say␈αthe␈αuser␈α
reponds␈αby␈α
calling␈αit␈αIMPOSS.␈α
This␈αnaming␈α
and␈αspecializing␈αis␈α
central
␈↓ d␈↓to␈α
BEING␈α
creation:␈αa␈α
BEING␈α
recognizes␈αan␈α
instance␈α
of␈α
itself,␈αand␈α
decides␈α
either␈αto␈α
insert␈α
a␈α
call␈αto␈α
itself␈α
or␈αelse␈α
to
␈↓ d␈↓insert␈α
a␈α∞call␈α
to␈α
a␈α∞specialized␈α
version␈α
of␈α∞itself.␈α
 If␈α
any␈α∞nontrivial␈α
decisions␈α
must␈α∞be␈α
made,␈α
and␈α∞can␈α
be␈α∞settled␈α
at
␈↓ d␈↓synthesis␈α
time,␈αthen␈α
the␈αlatter␈α
alternative␈αis␈α
chosen.␈α CONTRADICTS␈α
is␈α
too␈αgeneral␈α
a␈αBEING␈α
to␈αbe␈α
called␈αin␈α
an
␈↓ d␈↓inner␈α
loop,␈αso␈α
its␈αcontent␈α
will␈αbe␈α
hammered␈αout␈α
at␈αsynthesis␈α
time.␈αOn␈α
the␈αother␈α
hand,␈αFORSOME␈α
is␈αso␈α
primitive
␈↓ d␈↓that no  specialized version  of  it  is  written normally.
␈↓"/␈↓ d␈↓Here is the way this piece of the dialogue actually appears.  The user's reponses are italicized.

␈↓"	␈↓ d␈↓PUP: Please type in a logical expression which is true iff we terminate the loop
␈↓"	␈↓ d␈↓USER: ␈↓β(Any feature in model-features is incompatible with scene-features)␈↓
␈↓"	␈↓ d␈↓PUP: PUP wants USER to type in name for specialized version of CONTRADICTS
␈↓"	␈↓ d␈↓USER: ␈↓βIMPOSS␈↓
␈↓"/␈↓ d␈↓Later␈αin␈αthe␈α dialogue,␈α PUP6␈α decides␈α it␈α must␈αexpand␈αthe␈αfunction␈αIMPOSS.␈αThe␈αCONTRADICTS␈αBEING
␈↓ d␈↓is␈α
again␈α
called␈α
on;␈αthis␈α
time␈α
 it␈α
 is␈α
 asked␈α how␈α
 to␈α
 write␈α
 a␈α
 specialized␈α version␈α
  of␈α
  a␈α
contradiction␈α
 test.␈α It
␈↓ d␈↓replies␈α≥that␈α≡SOME-OF␈α≥the␈α≡following␈α≥types␈α≥of␈α≡contradiction␈α≥ may␈α≡ occur:␈α≥       PROBABILITY=0,
␈↓ d␈↓PROBABILITY=1,␈α  and␈α∨PROBABILITY␈↓βε␈↓(0,1).␈α    This␈α∨  is␈α   the␈α∨ germ␈α  of␈α∨ the␈α  idea␈α  for␈α∨ the
␈↓ d␈↓MUSTNOT/MUST/MAY␈αcategorization␈αof␈αfeatures.␈αThe␈αSOME-OF␈αBEING␈α takes␈αcontrol,␈α and␈α asks␈α if␈α the
␈↓ d␈↓decision␈αcan␈αbe␈α
deferred.␈α Eventually␈αthe␈α
DEFERRAL␈αBEING␈αreports␈α
failure.␈α SOME-OF␈αsees␈α
it␈αhas␈α no␈α
 basis
␈↓ d␈↓upon␈α
which␈α∞ to␈α
 form␈α∞ a␈α
 guess,␈α
 and␈α∞ wants␈α
somebody␈α∞to␈α
ask␈α
the␈α∞user.␈α
 The␈α∞ASK-USER␈α
BEING␈α∞takes␈α
over.
␈↓ d␈↓The␈αnames␈αof␈αthe␈αthree␈αchoices␈αare␈αso␈αcryptic␈αthat␈αtheir␈αWHAT␈αand␈αHOW␈αparts␈αare␈αprinted␈αout␈αto␈α the␈α user,
␈↓ d␈↓as␈α well␈α as␈αtheir␈αnames.␈α The␈αuser␈αtypes␈αback␈αhis␈αchoices,␈αin␈αour␈αcase␈αall␈αthree.␈α SOME-OF␈αregains␈αcontrol␈αand
␈↓ d␈↓composes  three  new  BEING  calls,   separated   by   a conditional:

␈↓"	␈↓ d␈↓α(COND
␈↓"	␈↓ d␈↓α ((IS-OF-TYPE  F  PROBABILITY=0-PART-OF-M-FEATURES) (PROBABILITY=0-CONTRADICTION  F  S-FEATURES))
␈↓"	␈↓ d␈↓α ((IS-OF-TYPE  F  PROBABILITY=1-PART-OF-M-FEATURES) (PROBABILITY=1-CONTRADICTION  F  S-FEATURES))
␈↓"	␈↓ d␈↓α ((IS-OF-TYPE  F  PROBABILITY␈↓βε␈↓α(0,1)-PART-OF-M-FEATURES) (PROBABILITY␈↓βε␈↓α(0,1)-CONTRADICTION  F  S-FEATURES)))
␈↓"/␈↓ d␈↓TRICHOTOMY␈αrecognizes␈αthis␈αas␈αa␈α
split␈αon␈αa␈αfunction's␈α values␈αbeing␈α
 =0,␈α =1,␈α or␈α between␈α zero␈α
 and␈α one.
␈↓ d␈↓It␈α∪ asks␈α∪whether␈α∪this␈α∪particular␈α∪ function␈α∩ can␈α∪ only␈α∪ range␈α∪ over␈α∪ the␈α∪  interval␈α∪  [0,1].␈α∩ PROBABILITY
␈↓ d␈↓answers␈α⊗ affirmatively,␈α⊗ so␈α⊗ SOME-OF␈α⊗ replaces␈α⊗the␈α⊗final␈α⊗IS-OF-TYPE␈α⊗test␈α⊗by␈α⊗the␈α⊗constant␈α⊗T.␈α⊗ The
␈↓ d␈↓contradiction␈αpredicates␈αknow␈α(their␈αENCODABLE␈α parts␈α tell␈α them)␈α that␈αthey␈α are␈α immediately␈αencodable.␈αA
␈↓ d␈↓probability=0␈αcontradiction␈αmeans␈α
that␈αarg1␈αmust␈α
not␈αoccur␈αin␈αthe␈α
 world␈α arg2␈α yet␈α
 it␈α does.␈α So␈α
 the␈αMETA-
␈↓ d␈↓CODE␈α of␈α the␈α PROBABILITY=0-CONTRADICTION␈α BEING␈α is␈αdefined␈αas␈α(MEMBER␈αarg1␈αarg2).␈α This
␈↓ d␈↓corresponds␈α
to␈α
a␈α
MUSTNOT␈α
feature␈α
F␈α
which␈α
is␈α
present␈α
 in␈α
 the␈α
 world␈α
 (in␈α
 the␈α
 set␈α
 S-FEATURES,␈α
features␈α
of
␈↓ d␈↓the␈α∞scene).␈α∞A␈α∞probability=1␈α∞contradiction␈α∂occurs␈α∞when␈α∞a␈α∞feature␈α∞arg1␈α∞must␈α∂occur␈α∞ in␈α∞the␈α∞ world␈α∞ arg2,␈α∂ yet␈α∞ it
␈↓ d␈↓doesn't.␈αSo␈αits␈αdefinition␈αis␈αsimply␈α(NOT␈α(MEMBER␈αarg1␈αarg2)).␈α It␈αis␈αimpossible␈αfor␈αa␈αfeature␈αwith␈αprobability
␈↓ d␈↓in␈α (0,1)␈α to␈α be␈α in␈α contradiction␈α with␈αany␈αworld␈α lacking␈αnegated␈αfeatures,␈αso␈αthis␈αthird␈αpredicate␈αis␈αdefined␈αas
␈↓ d␈↓the␈α
 constant␈α
 NIL.␈α
 That␈α
 is,␈α
 if␈α
F␈α
is␈α
a␈α
MAY␈αfeature␈α
of␈α
the␈α
model␈α
M,␈α
then␈α
there␈α
can␈α
be␈α
no␈αcontradiction␈α
between
␈↓ d␈↓F and ␈↓βany␈↓ features of the scene S.
␈↓"/␈↓ d␈↓The␈α
 IS-OF-TYPE␈α
 BEING␈α
 recognizes␈α
 that␈αit␈α
must␈α
work␈α
hard␈α
to␈α
replace␈αeach␈α
of␈α
the␈α
two␈α
case␈α
tests,␈αunless␈α
 M-
␈↓ d␈↓FEATURES␈α is␈α organized␈αpermanently␈α into␈α three␈α parts␈α(thus␈αpermitting␈αthe␈αcomplex␈αcalls␈α"IS-OF-TYPE"␈αto
␈↓ d␈↓be␈α∂replaced␈α∂by␈α∂the␈α∂simple␈α∂ones␈α∂"MEMBER"␈α∂in␈α∂ the␈α∂ above␈α∂piece␈α∂of␈α∂code).␈α∂The␈α∞STRUCTURE-INDUCING
␈↓ d␈↓BEING␈α
takes␈α
over,␈α
probing␈α
the␈α
permissability␈α
and␈α
the␈α
difficulty␈α
of␈α
such␈α
a␈α
constraint.␈α
 It␈α
finds␈α∞nothing␈α
 about
␈↓ d␈↓this␈α⊂ tripartite␈α⊂ structuring␈α∂ which␈α⊂could␈α⊂damage␈α⊂any␈α∂earlier␈α⊂synthesized␈α⊂code,␈α∂and␈α⊂asks␈α⊂the␈α⊂ user's␈α∂ blessing.
␈↓ d␈↓Demons␈αare␈α
created,␈αstating␈α
that␈αany␈α
reference␈αto␈α
the␈αentire␈α
list␈αof␈α
M-FEATURES␈αmust␈α
be␈αreplaced␈α
by␈α either
␈↓ d␈↓APPEND␈α of␈αthe␈α three␈α new␈αlists,␈αor␈αelse␈αby␈αthree␈αseparate␈αstatements.␈αGET-NAME␈αis␈αindirectly␈αcalled,␈αand␈αhe
␈↓ d␈↓has␈α
the␈α∞user␈α
name␈α
the␈α∞three␈α
new␈α
sets␈α∞ of␈α
features;␈α
say␈α∞he␈α
responds␈α
by␈α∞calling␈α
them␈α
MUSTNOT,␈α∞MUST,␈α
and
␈↓ d␈↓MAY.␈α
The␈α
system␈α
says␈α
to␈α
draw␈α
an␈α
arrow␈α
on␈α
its␈α
graph␈α
of␈α
newly␈α
created␈α
BEINGs,␈α
going␈α
from␈α
the␈α
BEING␈α
call
␈↓ d␈↓(IMPOSS F S-FEATURES) to the new block of code:

␈↓"	␈↓ d␈↓α  (COND  ((MEMBER  F  MUSTNOT-PART-OF-M)  (MEMBER  F  S-FEATURES))
␈↓"	␈↓ d␈↓α             ((MEMBER  F  MUST-PART-OF-M)     (NOT (MEMBER  F  S-FEATURES)))
␈↓"	␈↓ d␈↓α             ( T  (COMMENT THIS "T" REPLACES "MEMBER F MAY-PART-OF-M")  NIL))
␈↓"/␈↓ d␈↓This␈α∞is␈α∞now␈α∞the␈α
META-CODE␈α∞part␈α∞of␈α∞the␈α∞new␈α
BEING␈α∞called␈α∞IMPOSS.␈α∞ Most␈α
of␈α∞the␈α∞other␈α∞parts␈α∞are␈α
taken
␈↓ d␈↓from␈α∂its␈α∂generalization,␈α∂namely␈α∂CONTRADICTS.␈α∂During␈α∂the␈α∂course␈α∂of␈α∂writing␈α∂this␈α∂piece,␈α∂however,␈α⊂some␈α∂of
␈↓ d␈↓these␈α∞parts␈α∞should␈α∞be␈α∞slightly␈α∞changed.␈α∞For␈α∂example,␈α∞its␈α∞reason␈α∞for␈α∞existing␈α∞should␈α∞be␈α∞strengthened␈α∂when␈α∞the
␈↓ d␈↓simple MEMBER function calls replaced the slow IS-OF-TYPE  BEING calls.
␈↓"/␈↓ d␈↓Most␈αof␈αthis␈αprocessing␈αis␈αinter-BEING␈αactivity;␈αthe␈αuser␈αis␈αnot␈αneeded␈αfor␈α--␈αor␈αeven␈αinformed␈αof␈α--␈αmost␈αof␈α
it.
␈↓ d␈↓Alas, "the user" is  not  generic;  there was  only one successful user.
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α;␈↓∧␈↓&11. Excerpt from the synthesized program itself running␈↓)αβ␈↓
␈↓"/␈↓ d␈↓The␈α∂PUP6␈α∂system␈α∂interacts␈α∂with␈α∂the␈α∂user,␈α∂resulting␈α∂in␈α∂the␈α∂creation␈α∂of␈α∂CF,␈α∂the␈α∂desired␈α∂target␈α∂program.␈α∞ Like
␈↓ d␈↓PUP6,␈αCF␈αis␈αnothing␈αbut␈αa␈αpool␈αof␈αBEINGs.␈αSo,␈αas␈αit␈αruns,␈αthe␈αuser␈αcan␈αinterrupt␈αit␈αand␈αask␈αit␈αquestions␈αabout
␈↓ d␈↓what␈αit's␈α
doing.␈αThe␈αanswers␈α
are␈αtypically␈α
just␈αsome␈αparts␈α
of␈αthe␈α
BEING␈αcurrently␈αin␈α
control.␈α Any␈α
BEING␈αon
␈↓ d␈↓the␈αcontrol␈αstack␈αwill␈αprovide␈αfully␈αinstantiated␈αanswers␈αto␈αany␈αof␈αits␈α29␈αallowable␈αqueries;␈αall␈αother␈αBEINGs␈αwill
␈↓ d␈↓provide␈αonly␈αhypothetical␈αanswers.␈α An␈αexcerpt␈αof␈αCF␈αrunning␈αwithout␈αinterruption␈αis␈αgiven␈αbelow,␈αfollowed␈αby
␈↓ d␈↓the␈αsame␈α
piece␈αwith␈α
interruptions.␈αThe␈αcharacters␈α
of␈αthe␈α
dialogues␈αwith␈α
PUP6␈αto␈αwrite␈α
CF,␈αand␈α
with␈αCF␈αto␈α
learn
␈↓ d␈↓concepts,␈αare␈α
similar;␈αan␈α"interrupted"␈α
excerpt␈αof␈αthe␈α
user-PUP6␈αdialogue␈α
will␈αbe␈αomitted.␈α
 Some␈αliberty␈αhas␈α
been
␈↓ d␈↓taken with the English (e.g., ␈↓βWHAT?␈↓, not ␈↓βWhat are you doing?␈↓).  PUP6 types in boldface, the user in italics.

␈↓"	␈↓ d␈↓↓READY TO ACCEPT BRAND NEW SCENE:   ␈↓β(??? (A B) (Block A) (Green B) (Touches A B))␈↓↓
␈↓"	␈↓ d␈↓↓NOT AN ARCH. NOT A TOWER. MIGHT BE A ROW.  MY GUESS IS ROW.
␈↓"	␈↓ d␈↓↓WHAT IS IT REALLY?                 ␈↓βNothing␈↓↓
␈↓"	␈↓ d␈↓↓TRANSFER FROM MAY TO MUST SETS OF ROW: (TOUCH A B)
␈↓"	␈↓ d␈↓↓READY TO ACCEPT BRAND NEW SCENE:
␈↓"/␈↓ d␈↓Here␈α
is␈α
the␈α
␈↓βsame␈↓␈α
excerpt,␈α
but␈α
with␈α
the␈αuser␈α
interrupting␈α
occasionally.␈α
 "␈↓βU:␈↓"␈α
signifies␈α
he␈α
has␈α
interrupted,␈αand␈α
"␈↓βOK.␈↓"
␈↓ d␈↓signifies he has told PUP6 "␈↓βOK, go back to work now.␈↓"

␈↓"	␈↓ d␈↓↓        ␈↓βU:  What are you doing?␈↓↓
␈↓"	␈↓ d␈↓↓PUP:  Divide a domain into subdomains, using specialized version of PARTITION-DOMAIN
␈↓"	␈↓ d␈↓↓        ␈↓βHow?␈↓↓
␈↓"	␈↓ d␈↓↓PUP:  By building up the partition gradually, by adding one <scene, name> pair. ␈↓βOK.␈↓↓

␈↓"	␈↓ d␈↓↓READY TO ACCEPT BRAND NEW SCENE:   ␈↓β(??? (A B) (Block A) (Green B) (Touches A B))␈↓↓

␈↓"	␈↓ d␈↓↓        ␈↓βU:  What are you doing?␈↓↓
␈↓"	␈↓ d␈↓↓PUP:  Break NAME piece off (??? (A B) (BLOCK A) (GREEN B) (TOUCHES A B)) to examine.
␈↓"	␈↓ d␈↓↓        ␈↓βWhat code is the current BEING going to execute?␈↓↓
␈↓"	␈↓ d␈↓↓PUP:  The meta-code of SOME-PART-OF␈↓#v1␈↓#␈↓#v4␈↓# is (CAR arg1). Evals to ???. ␈↓βOK.␈↓↓

␈↓"	␈↓ d␈↓↓NOT AN ARCH.
␈↓"	␈↓ d␈↓↓        ␈↓βU:  Why?␈↓↓
␈↓"	␈↓ d␈↓↓PUP: The ARCH MUST-relation (SUPPORTS A B) is contradicted in the SCENE. ␈↓βOK.␈↓↓
␈↓ d␈↓↓NOT A TOWER. MIGHT BE A ROW.  MY GUESS IS ROW.
␈↓"	␈↓ d␈↓↓WHAT IS IT REALLY?                 ␈↓βU:  Why are you asking?␈↓↓
␈↓"	␈↓ d␈↓↓PUP: PUP cannot resolve it, and must at this time, so PUP asks USER
␈↓"	␈↓ d␈↓↓        ␈↓βOK. What you wanted is:   Nothing␈↓↓

␈↓"	␈↓ d␈↓↓        ␈↓βU:  What are you doing?␈↓↓
␈↓"	␈↓ d␈↓↓PUP: Go through space of concept names, and make user aware of changes.
␈↓"	␈↓ d␈↓↓        ␈↓βWhat BEINGs might this affect?␈↓↓
␈↓"	␈↓ d␈↓↓PUP: MESSAGE is possibly called; some version of TEST is possibly called.  ␈↓βOK.␈↓↓

␈↓"	␈↓ d␈↓↓TRANSFER FROM MAY TO MUST SETS OF ROW: (TOUCH A B)
␈↓"	␈↓ d␈↓↓READY TO ACCEPT BRAND NEW SCENE:

␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α~␈↓∧␈↓&12. Other Tasks␈↓)αβ␈↓
␈↓"/␈↓ d␈↓Let␈α∞ us␈α
 briefly␈α∞ describe␈α∞ GI␈α
 and␈α∞ PL,␈α∞the␈α
second␈α∞and␈α∞third␈α
programs␈α∞PUP6␈α∞synthesized.␈α
  GI␈α∞ is␈α∞ a␈α
 simple
␈↓ d␈↓grammatical␈α
inference␈α
program.␈α∞It␈α
builds␈α
up␈α
a␈α∞set␈α
of␈α
plausible␈α
 rules,␈α∞rather␈α
 than␈α
 enumerating␈α∞ through␈α
 the
␈↓ d␈↓space␈α⊂of␈α⊂all␈α⊂grammars.␈α⊂Yet␈α⊂it␈α⊂lacks␈α⊂most␈α⊂of␈α∂the␈α⊂"tricks"␈α⊂of␈α⊂ the␈α⊂ best␈α⊂ g.i.␈α⊂ programs.␈α⊂  The␈α⊂ user␈α∂repeatedly
␈↓ d␈↓specifies␈α
a␈αstring,␈α
labelled␈αLEGAL,␈α
ILLEGAL,␈α
or␈α??.␈α
In␈αthe␈α
latter␈α
case,␈αGI␈α
must␈αprint␈α
out␈α
its␈αguess␈α
and␈αaccept␈α
the
␈↓ d␈↓correct␈α∂label␈α⊂from␈α∂ the␈α⊂ user.␈α∂  In␈α∂ all␈α⊂ three␈α∂ cases,␈α⊂ it␈α∂ must␈α∂update␈α⊂its␈α∂set␈α⊂of␈α∂plausible␈α∂rules␈α⊂to␈α∂be␈α⊂at␈α∂ least
␈↓ d␈↓consistent␈α
 with␈α
 all␈α
 positive␈α
 and␈αnegative␈α
 instances␈α
 observed.␈α
In␈α
some␈α
versions␈αof␈α
GI␈α
the␈α
user␈α
coaxes␈αPUP6␈α
to
␈↓ d␈↓generate,␈α
a␈αparse␈α
tree␈α
may␈αbe␈α
maintained␈α
 and␈α inspected;␈α
 in␈α
other␈αversions,␈α
just␈α
a␈αlist␈α
of␈α
the␈αrules␈α
used␈αduring␈α
a
␈↓ d␈↓parse is kept.
␈↓"/␈↓ d␈↓PL␈αis␈αa␈αdata-retrieval-on-keys␈αsystem,␈αwhich␈αmaintains␈αa␈αproperty␈αlist␈αstructure.␈α The␈αuser␈αrepeatedly␈αtypes␈αin␈αa
␈↓ d␈↓request␈αto␈αinsert,␈αdelete,␈αor␈α
inspect␈αa␈α record␈α (e.g.,␈α INSERT:␈α
PASSENGER␈α Jones␈α FLIGHT␈α 741␈α FROM␈α
SFO
␈↓ d␈↓TO␈α
LAX␈αCARRIER␈α
TWA␈α
LEAVE␈α7:15␈α
ARRIVE␈α8:00).␈α
 Any␈α
unspecified␈αfields␈α
are␈αtreated␈α
 as␈α
 dont't␈α cares;
␈↓ d␈↓thus the request is matched against entries in the data base.
␈↓"/␈↓ d␈↓The␈α
table␈α
below␈α
shows␈α
how␈αeach␈α
type␈α
of␈α
knowledge␈α
was␈α
used␈α in␈α
writing␈α
the␈α
three␈α
target␈α
programs.␈α All␈α
numbers
␈↓ d␈↓refer to BEINGs.

␈↓"	␈↓ d␈↓ε␈α?␈α?␈α8        ␈↓∧U  S  E  D     I  N     S  Y  N  T  H  E  S  I  Z  I  N  G␈↓ε

␈↓"	␈↓ d␈↓ε␈↓ ↓DTYPE OF          CF    CF    CF    CF     GI    PL     not     Crea    Crea    Crea    Total
␈↓"	␈↓ d␈↓ε␈↓ ↓DKNOWLEDGE        GI    GI    PL  only   only   only    used    -ted    -ted    -ted    BEINGs
␈↓"	␈↓ d␈↓ε␈↓ ↓D                 PL  only   only                       ever    in CF   in GI   in PL

␈↓"	␈↓ d␈↓ε␈↓ ↓DProgramming      39     7     5     5     3      1       14       52      27      21      174
␈↓"	␈↓ d␈↓ε␈↓ ↓DDomain-Specific   0     3     0     9     8      1        5        4      10       3       43
␈↓"	␈↓ d␈↓ε␈↓ ↓DTotal BEINGs     39    10     5    14    11      2       19       56      37      24      217
␈↓ d␈↓"Created"␈α⊗means␈α⊗"written␈α⊗by␈α⊗PUP6␈α⊗during␈α↔the␈α⊗dialogue␈α⊗which␈α⊗synthesized".␈α⊗ Notice␈α⊗the␈α↔percentage␈α⊗of
␈↓ d␈↓programming␈α∞BEINGs␈α∞ which␈α
 were␈α∞used␈α∞in␈α∞ all␈α
three␈α∞dialogues.␈α∞The␈α
three␈α∞domain-specific␈α∞BEINGs␈α∞used␈α
in
␈↓ d␈↓both␈αCF␈αand␈α
GI␈α sessions␈α indicate␈α that␈α
 they␈α may␈α be␈α Inductive␈α
Inference␈α domain␈αspecific.␈α They␈α
deal␈αwith
␈↓ d␈↓partitioning a domain, and aren't used in PL, which is not an inductive inference task.
␈↓"/␈↓ d␈↓Although␈α
BEINGs␈α
can␈α
theoretically␈α
handle␈α
user␈α
errors,␈α
PUP6␈α
was␈α
set␈α
up␈α
expecting␈α
that␈α
the␈α
user␈α
would␈α
never
␈↓ d␈↓err␈α∞or␈α∂ forget.␈α∞ He␈α∂could,␈α∞after␈α∞the␈α∂program␈α∞was␈α∂finished,␈α∞try␈α∂it␈α∞out␈α∞and␈α∂describe␈α∞how␈α∂he␈α∞wished␈α∂it␈α∞changed.
␈↓ d␈↓Occasionally,␈αPUP6␈α actually␈α make␈αthe␈α right␈αmodifications.␈αFor␈αexample,␈αafter␈αthe␈αsynthesis␈αof␈αPL␈αis␈αfinished,
␈↓ d␈↓the␈α∂user␈α∂tries␈α∞out␈α∂the␈α∂program␈α∂and␈α∞finds␈α∂that␈α∂he␈α∂is␈α∞unable␈α∂to␈α∂delete␈α∂more␈α∞ than␈α∂ one␈α∂reservation␈α∂ with␈α∞ any
␈↓ d␈↓single␈α
 command.␈α
He␈α
complains␈α
about␈α
this,␈α
and␈α
PUP6␈αmodifies␈α
the␈α
program␈α
so␈α
that␈α
he␈α
may␈α
specify␈α
a␈αpattern,
␈↓ d␈↓and␈α all␈αreservations␈α matching␈α that␈α pattern␈α will␈α be␈α purged.␈α  There␈αis␈αonly␈αone␈αsentence,␈αhowever,␈αwhich␈αis
␈↓ d␈↓able to effect this change; the slightest deviation would cause it to be misunderstood!
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α)␈↓∧␈↓&13. Numerical efficiency data␈↓)αβ␈↓
␈↓"/␈↓ d␈↓Good␈α⊃measures␈α⊃ of␈α⊃ concentration␈α⊃ of␈α⊃intelligence␈α⊃are␈α∩not␈α⊃yet␈α⊃available.␈α⊃ The␈α⊃only␈α⊃alternative␈α⊃is␈α∩to␈α⊃present
␈↓ d␈↓ephemeral␈α numerical␈αefficiency␈α data,␈α which␈αnow␈α
follows.␈αPUP6␈αis␈α200␈αpages␈αlong␈αwhen␈α
PRETTY-PRINTED,
␈↓ d␈↓and has synthesized three programs, 7, 20, and 30 pages long (1, 4, and 6 pages, when coded by hand.)
␈↓"/␈↓ d␈↓Two␈αimportant␈αfactors␈α
are␈αomitted␈αwhen␈αsimply␈α
comparing␈αsystem␈αand␈αtarget␈α
lengths.␈αFirst,␈αone␈α
might␈αimprove
␈↓ d␈↓any␈α
such␈α∞measure␈α
by␈α∞simply␈α
decreasing␈α
the␈α∞size␈α
of␈α∞a␈α
given␈α∞system.␈α
This␈α
is␈α∞wrong,␈α
since,␈α∞e.g.,␈α
removing␈α∞all␈α
the
␈↓ d␈↓comments␈αfrom␈αa␈αprogram␈αshouldn't␈αincrease␈αits␈αintelligence␈αrating!␈α Secondly,␈αthe␈αtotal␈αvolume␈αof␈αdistinct␈αtarget
␈↓ d␈↓programs␈α∞should␈α∞be␈α∞considered.␈α∞Compilers␈α∞turn␈α∞out␈α
programs␈α∞small␈α∞compared␈α∞to␈α∞themselves,␈α∞but␈α∞are␈α
valuable
␈↓ d␈↓because␈α⊂of␈α⊂the␈α⊂vast␈α⊂variety␈α⊂of␈α⊂such␈α⊂programs␈α⊂they␈α∂can␈α⊂put␈α⊂together.␈α⊂ This␈α⊂factor␈α⊂reflects␈α⊂how␈α⊂much␈α⊂of␈α∂the
␈↓ d␈↓"insides" of the system can be used in writing many programs.
␈↓"/␈↓ d␈↓PUP6␈α takes␈α 60␈α cpu␈αminutes␈αto␈αproduce␈αCF␈α(compiled␈αINTERLISP␈αcode,␈αrun␈αon␈αa␈αPDP-10␈αTENEX␈αsystem).
␈↓ d␈↓During␈α⊃this␈α⊂time,␈α⊃300K␈α⊂characters␈α⊃get␈α⊂typed␈α⊃out␈α⊂to␈α⊃the␈α⊂user,␈α⊃who␈α⊂ reponds␈α⊃ with␈α⊂ about␈α⊃4K␈α⊃ himself.␈α⊂The
␈↓ d␈↓dialogue␈α
lengths␈αare␈α
best␈αspecified␈α
in␈α
characters,␈αsince␈α
often␈αthe␈α
user␈αwill␈α
supply␈α
simply␈αa␈α
number␈αor␈α
 a␈α letter␈α
 or
␈↓ d␈↓a␈α
YES/NO␈α reply.␈α
 Even␈α the␈α
 character␈α counts␈α
 are␈αvery␈α
 rough,␈α because␈α
 the␈α format␈α
 of␈α the␈α
AP␈αdialogue␈α
can
␈↓ d␈↓easily␈αbe␈αvaried␈αby␈αa␈αcouple␈αorders␈αof␈αmagnitude.␈α The␈αmean␈αwait␈αtime␈α (between␈αthe␈αuser's␈αinput␈αand␈αthe␈αnext
␈↓ d␈↓machine␈α∞output)␈α∞is␈α∞several␈α∂seconds.␈α∞The␈α∞longest␈α∞delay␈α∞ between␈α∂ successive␈α∞ user␈α∞ inputs␈α∞ is␈α∞ 1␈α∂ CPU␈α∞ minute.
␈↓ d␈↓Unfortunately,␈α PUP6␈α requires␈α100K␈α
to␈αrun␈αin,␈αwhich␈α(with␈α
INTERLISP)␈αexhausts␈αthe␈αvirtual␈αmemory␈α
of␈αthe
␈↓ d␈↓current␈αhardware␈α
being␈α used.␈α
 One␈αwould␈αlose␈α
vast␈αamounts␈α
of␈αtime␈αby␈α
using␈αintermediate␈α
storage␈αdevices␈αor␈α
by
␈↓ d␈↓running␈αconsecutive␈α
communicating␈αjobs.␈α
Efficient␈αuse␈αof␈α
multiple␈αprocessors␈α
and␈αof␈α
extended␈αcore␈αstorage␈α
might
␈↓ d␈↓be made.
␈↓ d␈↓PL␈α
 was␈α one␈α
fifth␈α
the␈αsize␈α
of␈αCF,␈α
and␈α
took␈αabout␈α
a␈α
seventh␈αas␈α
long␈αto␈α
generate.␈α
The␈αdialogue␈α
was␈α
shorter␈αby
␈↓ d␈↓only␈αa␈α
factor␈αof␈αthree.␈α
The␈αdialogue␈αfor␈α
the␈αCF␈αtarget␈α
program␈αwas␈αtoo␈α
long␈αand␈αtiresome;␈α
the␈αproblem␈αwas␈α
even
␈↓ d␈↓more acute for the PL program.
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α#␈↓∧␈↓&14. Conclusions␈↓)αβ␈↓
␈↓"/␈↓ d␈↓The␈α∂ main␈α⊂ successes␈α∂ of␈α⊂the␈α∂experiment␈α⊂were␈α∂that␈α∂the␈α⊂desired␈α∂reasoning␈α⊂steps␈α∂in␈α⊂the␈α∂original␈α⊂protocol␈α∂were
␈↓ d␈↓actually␈α⊃simulated,␈α⊃most␈α⊃of␈α∩the␈α⊃BEINGs␈α⊃were␈α⊃used␈α∩in␈α⊃ writing␈α⊃ more␈α⊃ than␈α∩one␈α⊃of␈α⊃the␈α⊃programs,␈α∩and␈α⊃the
␈↓ d␈↓synthesized␈α⊂code␈α⊂could␈α⊃be␈α⊂interrupted␈α⊂and␈α⊂asked␈α⊃a␈α⊂few␈α⊂kinds␈α⊂of␈α⊃ questions.␈α⊂  The␈α⊂ main␈α⊂defects␈α⊃ were␈α⊂ the
␈↓ d␈↓inflexibility␈α∂of␈α∂the␈α⊂system␈α∂to␈α∂new␈α⊂dialogues,␈α∂the␈α∂inability␈α⊂for␈α∂ the␈α∂ user␈α⊂ to␈α∂ add␈α∂ new,␈α⊂ high-level,␈α∂ domain-
␈↓ d␈↓specific␈α⊃knowledge,␈α⊃ the␈α⊃verbosity␈α∩of␈α⊃the␈α⊃system,␈α⊃and␈α⊃its␈α∩ill-founded␈α⊃dependence␈α⊃on␈α⊃user␈α∩reliability.␈α⊃ These
␈↓ d␈↓problems␈αseem␈αto␈αbe␈αinherent␈αin␈αthe␈αtask␈αof␈αautomatic␈αsynthesis␈αof␈αlarge␈αprograms.␈α The␈αsmall␈αfraction␈αof␈αparts
␈↓ d␈↓which␈α∩were␈α∩actually␈α∩relevant␈α∩to␈α∩each␈α∩BEING␈α∩(a␈α∩third)␈α∩indicates␈α∩that␈α∩this␈α∩scheme␈α∩should␈α∩be␈α∩used␈α∩as␈α∩one
␈↓ d␈↓mechanism in some AI systems, but not as the sole curator of information and control.
␈↓"/␈↓ d␈↓The␈α fact␈α that␈αtarget␈αcode␈α
is␈αin␈αthe␈αformat␈αof␈α
BEINGs␈αlimits␈αthe␈αsize␈αof␈α
the␈αtarget␈αprograms␈α(≥␈αone␈α
page)␈αand
␈↓ d␈↓their␈αefficiency␈α (a␈α
BEING-call␈α is␈αa␈αvery␈α
slow␈αand␈αintricate␈α
process)␈αand␈αof␈αcourse␈α
their␈αstyle.␈αThe␈αmost␈α
startling
␈↓ d␈↓result␈α
--␈α∞which␈α
should␈α
have␈α∞been␈α
forseen␈α
--␈α∞was␈α
that␈α
the␈α∞synthesized␈α
code␈α
has␈α∞all␈α
the␈α
properties␈α∞of␈α
BEINGs.
␈↓ d␈↓This␈αwas␈α
mentioned␈αcasually␈αearlier,␈α
but␈αis␈αworth␈α
restating:␈αthe␈α
generated␈αcode␈αis␈α
 self-commenting␈α in␈αthe␈α
strong
␈↓ d␈↓sense␈αthat␈αit␈αcan␈αanswer␈αany␈α
(of␈αour␈αset␈αof␈α29)␈αquestions␈α
about␈αitself.␈α Those␈αwhich␈αmake␈αsense␈α
at␈αcompile-time
␈↓ d␈↓can  be  asked  then;  those  which  make  sense during execution may be asked then.
␈↓"/␈↓ d␈↓The␈αset␈α
of␈αquestions␈α
the␈αuser␈αwas␈α
expected␈αto␈α
want␈αto␈αask␈α
the␈αsystem␈α
 is␈α similar␈α to␈α
the␈αquestions␈α
one␈αBEING
␈↓ d␈↓wants␈α∞to␈α∞ask␈α∞another.␈α∞ So␈α∂when␈α∞the␈α∞"nice"␈α∞user␈α∞interrupts,␈α∞his␈α∂questions␈α∞are␈α∞almost␈α∞always␈α∞a␈α∂simple␈α∞ retrieval
␈↓ d␈↓from␈αa␈αproperty␈α
list␈α(a␈αGETP␈αor␈α
a␈αcomposition␈αlike␈α
EVAL␈αo␈αGETP).␈αWhen␈α
the␈αaverage␈α user␈α
 interrupts,␈α his
␈↓ d␈↓questions  are unintelligible to PUP6.
␈↓"/␈↓ d␈↓Meaningful␈α
use␈αof␈α
comments␈αproved␈α
helpful.␈α
As␈αan␈α
example,␈αthe␈α
comment␈αat␈α
the␈α
end␈αof␈α
the␈αmain␈α
outer␈αloop␈α
was
␈↓ d␈↓"COMMENT,␈α∞INFINITE␈α∞LOOP␈α
IN␈α∞THIS␈α∞PROG"␈α∞for␈α
most␈α∞of␈α∞the␈α∞CF-producing␈α
session.␈α∞Near␈α∞the␈α∞ end␈α
of
␈↓ d␈↓the␈α∞ dialogue,␈α∂the␈α∞ CLARIFY-IMPROBABLE-SITUATION␈α∂BEING␈α∞recognizes␈α∂this␈α∞as␈α∂a␈α∞warning,␈α∂works␈α∞on
␈↓ d␈↓introducing␈α
a␈α
breakaway␈α
 test,␈α and␈α
 then␈α
replaces␈α
 the␈α comment␈α
by␈α
one␈α
indicating␈αthat␈α
no␈α
infinite␈α
loop␈αexists
␈↓ d␈↓there␈αanymore.␈α  The␈α advantage␈α of␈α embedding␈α our␈αinsertions␈αin␈α
the␈αcode␈αin␈αthis␈αway␈αis␈αthat,␈αat␈αany␈αstage,␈α
the
␈↓ d␈↓user can inspect the code and get something meaningful  out  of  the  comments which are present.
␈↓"/␈↓ d␈↓The␈α careful␈α bookkeeping␈α  actually␈α  did␈α
  eliminate␈α  some␈αcarelessness␈α errors,␈αthough␈α
it␈αhad␈αno␈αeffect␈αon␈α
user
␈↓ d␈↓errors␈α∪or␈α∀later␈α∪program␈α∀maintenance␈α∪ directives.␈α∀ This␈α∪  last␈α∀   process␈α∪    is␈α∀ less␈α∪ill-defined␈α∀ than␈α∪ blind
␈↓ d␈↓debugging,␈α⊂and␈α⊂in␈α⊂fact␈α⊂is␈α⊃ similar␈α⊂to␈α⊂programming␈α⊂itself.␈α⊂ The␈α⊃deferral␈α⊂ of␈α⊂ decisions␈α⊂ has␈α⊂ the␈α⊃corollary␈α⊂of
␈↓ d␈↓reducing (though not minimizing) communication with the slow user channel.
␈↓"/␈↓ d␈↓Synthesizing␈α∀a␈α∪new,␈α∀clean␈α∪target␈α∀program␈α∪ probably␈α∀ would␈α∪ require␈α∀adding␈α∪ a␈α∀ few␈α∪domain-independent
␈↓ d␈↓BEINGs␈α∂and␈α∂several␈α∂domain-specific␈α∂BEINGs,␈α∂and␈α∞generalizing␈α∂several␈α∂parts␈α∂of␈α∂ several␈α∂ existing␈α∞ BEINGs.
␈↓ d␈↓Since␈α∃ the␈α∃ dialogues␈α∀ for␈α∃ GI␈α∃ and␈α∃PL␈α∀were␈α∃not␈α∃studied␈α∀before-hand,␈α∃their␈α∃acceptability␈α∃ would␈α∀ have
␈↓ d␈↓demonstrated␈α∂ the␈α∞ success␈α∂ of␈α∂ the␈α∞system.␈α∂ Most␈α∂of␈α∞the␈α∂existing␈α∞BEINGs␈α∂were␈α∂used␈α∞in␈α∂generating␈α∂these␈α∞new
␈↓ d␈↓programs,␈αbut␈αa␈αfew␈αnew␈αBEINGs␈αhad␈αto␈αbe␈αadded.␈αThis␈αaddition␈αprocess␈αrequired␈αsome␈αdetailed␈αknowledge␈αof
␈↓ d␈↓the␈α⊂PUP6␈α⊂system,␈α⊂not␈α⊂just␈α⊂of␈α⊂the␈α⊂domain.␈α⊂ Equally␈α⊂discouraging,␈α⊂the␈α⊂dialogue␈α⊂to␈α⊂write␈α⊂PL␈α⊂is␈α⊂too␈α⊂long␈α⊂and
␈↓ d␈↓detailed␈αfor␈αthe␈αtask␈αat␈αhand.␈α It␈αalso␈α seems␈α that␈α the␈α front␈α end␈α is␈α too␈αbrittle␈α to␈α allow␈α anyone␈α unfamiliar
␈↓ d␈↓with the system to easily work with it.
␈↓"/␈↓ d␈↓The␈α∪need␈α∪for␈α∪flexible␈α∪communication␈α∪stems␈α∪ only␈α∪partially␈α∪from␈α∪inter-user␈α∪ differences.␈α∪  A␈α∪ serious␈α∪ and
␈↓ d␈↓unexpected␈α∞source␈α
 of␈α∞ conflict␈α
 here␈α∞ is␈α
the␈α∞amount␈α
of␈α∞inference␈α
the␈α∞user␈α
wants␈α∞done.␈α
 This␈α∞level␈α∞is␈α
relatively
␈↓ d␈↓subjective,␈α
and␈α
may␈α
fluctuate␈α
rapidly␈αeven␈α
 with␈α
 one␈α
 user␈α
 writing␈α
one␈αprogram.␈α
Perhaps␈α
there␈α
should␈α
be␈αa␈α
dial
␈↓ d␈↓he␈αcan␈αset.␈αAt␈α
one␈αextreme,␈αthe␈αsystem␈αwould␈α
 ask␈α the␈α user␈α to␈αverify␈α
 even␈α the␈α most␈α trivial␈α
 inductions.␈α At
␈↓ d␈↓the␈α∞ other␈α∞extreme␈α∞setting,␈α∞the␈α∞system␈α∞would␈α∞probably␈α∂write␈α∞ the␈α∞ target␈α∞ program␈α∞ after␈α∞just␈α∞a␈α∞few␈α∂brief␈α∞user
␈↓ d␈↓inputs.␈αThe␈αuser␈α
would␈αthen␈αtry␈αout␈α
one␈αprogram␈αafter␈α
another,␈αinterjecting␈αjust␈αone␈α
or␈αtwo␈αcomments␈αeach␈α
time,
␈↓ d␈↓after␈α∪which␈α∩ the␈α∪ system␈α∪would␈α∩come␈α∪up␈α∩with␈α∪the␈α∪next␈α∩version.␈α∪ This␈α∩program␈α∪modification␈α∪mode␈α∩seems
␈↓ d␈↓appropriate for someone ignorant of LISP, who nevertheless has the I/O behavior of his target clearly in mind.
␈↓"/␈↓ d␈↓Some␈α⊂of␈α⊂the␈α⊂BEING␈α⊂parts␈α⊂ proved␈α⊂ embarrassingly␈α⊂ unnecessary.␈α⊂ The␈α⊂ CO-REQUISITES␈α⊂ part␈α⊂was␈α⊂never
␈↓ d␈↓used.␈α The␈αonly␈αactivity␈α
which␈αhad␈αto␈αbe␈α
done␈αconcurrently␈αwas␈αdemon␈α
activation.␈αThe␈αAFFECTS␈αpart␈α
was␈αof
␈↓ d␈↓interest␈α⊂ to␈α∂ the␈α⊂ user␈α∂ occasionally,␈α⊂ but␈α∂ never␈α⊂to␈α⊂any␈α∂BEING.␈α⊂ The␈α∂EFFECTS␈α⊂part␈α∂originally␈α⊂had␈α⊂a␈α∂twin,
␈↓ d␈↓describing␈αwhat␈α
would␈α happen␈α
 if␈αeach␈α
 BEING␈α were␈α
 ␈↓βnot␈↓␈α called␈αright␈α
now.␈α In␈α
each␈αcase,␈α
this␈αwas␈α
merely␈αa
␈↓ d␈↓trivial␈α
restatement␈αof␈α
the␈α
frame␈αproblem.␈α
 So,␈α
 like␈α STRIPS,␈α
PUP6␈α
 ignores␈α the␈α
 frame␈α
 problem:␈α    all␈α
changes
␈↓ d␈↓must be explicit.
␈↓"/␈↓ d␈↓Much␈α
 of␈α
PUP6's␈α
comments␈αare␈α
boring␈α
and␈α
unnecessary;␈αthis␈α
was␈α
felt␈α
to␈αbe␈α
an␈α
engineering␈α
problem␈αwhich␈α
would
␈↓ d␈↓be␈αignored␈αin␈αall␈αbut␈αa␈α"marketable"␈α AP␈αsystem.␈αThis␈αview␈αwas␈αprobably␈αincorrect.␈αOne␈αof␈αthe␈αmost␈αsevere␈αAP
␈↓ d␈↓problems␈α∞is␈α∂having␈α∞ the␈α∂ system␈α∞ inform␈α∂ the␈α∞ user␈α∂ of␈α∞precisely␈α∞ what␈α∂ he␈α∞should␈α∂know␈α∞--␈α∂no␈α∞more␈α∂nor␈α∞less.
␈↓ d␈↓This requires a sophisticated  user  model  cleverly  interfaced   to   the   current programming task.
␈↓"/␈↓ d␈↓Another␈αproblem␈αwith␈αlarge,␈αlong␈α
dialogues␈αis␈αuser␈α error.␈α A␈αhuman␈α
 has␈α great␈α difficulty␈αkeeping␈α"on␈α
top"␈αof
␈↓ d␈↓everything.␈α He␈αmay␈αget␈αlost,␈αforget,␈αchange␈αhis␈α mind,␈α or␈α misunderstand.␈α Again,␈α this␈αproblem␈α was␈αoriginally
␈↓ d␈↓considered␈α∞ignorable,␈α∞but␈α∞has␈α∞shown␈α∞itself␈α∞to␈α∞be␈α∞ a␈α∞ limiting␈α∞ practical␈α∞ factor␈α∞ in␈α∞ wide␈α∞ accessability.␈α∞ It␈α
 was
␈↓ d␈↓necessary␈α⊃ to␈α⊃ create␈α⊃ a␈α⊂ forgetful-user␈α⊃ demon␈α⊃ to␈α⊃prevent␈α⊂anaphoric␈α⊃reference␈α⊃to␈α⊃something␈α⊃which,␈α⊂though
␈↓ d␈↓uniquely␈αdetermined,␈α
hadn't␈αbeen␈αmentioned␈α
within␈αthe␈α
past␈αseveral␈αseconds.␈α
 Related␈αto␈αthis␈α
is␈αthe␈α
problem␈αof
␈↓ d␈↓keeping␈α∞the␈α
user␈α∞informed␈α
of␈α∞where␈α
he␈α∞is.␈α
PUP6␈α∞simulated␈α
a␈α∞continuous␈α
display␈α∞of␈α
 the␈α∞graph␈α
of␈α∞the␈α
current
␈↓ d␈↓partial␈αprogram,␈αaugmented␈αby␈αstatic␈αand␈αdynamic␈αcursors.␈αThis␈α simple␈αuse␈α of␈α dynamic␈α and␈α textual␈α indices
␈↓ d␈↓seems␈αinsufficient.␈α  The␈α user␈αwas␈αstill␈αoften␈αconfused,␈α
wishing␈αa␈αsection␈αreferred␈αto␈αnot␈αby␈αpointing␈α
but␈αrather
␈↓ d␈↓by␈αa␈αbrief,␈αmeaningful␈α(to␈αhim␈αonly!)␈α phrase.␈α  This␈αmay␈αalso␈αbe␈αone␈αof␈αthe␈αmajor␈αAP␈αproblems␈αwhich␈αmust␈αbe
␈↓ d␈↓studied further.
␈↓"/␈↓ d␈↓Will␈α∞we␈α∂ever␈α∞need␈α∂a␈α∞system␈α∂whose␈α∞target␈α∂programs␈α∞will␈α∞be␈α∂longer␈α∞and␈α∂more␈α∞complex␈α∂than␈α∞the␈α∂system␈α∞ itself?
␈↓ d␈↓Why␈α∂couldn't␈α∞we␈α∂settle␈α∞for␈α∂a␈α∞truly␈α∂intelligent␈α∂AP␈α∞system␈α∂several␈α∞times␈α∂as␈α∞large␈α∂as␈α∞anything␈α∂it␈α∂could␈α∞produce?
␈↓ d␈↓Worries␈α about␈αlarge␈αdialogues␈αarise␈αbecause␈αfuture␈αAP␈αsystems␈αare␈αviewed␈αas␈αtools␈αfor␈αwriting␈αprograms␈αwhich
␈↓ d␈↓humans␈α
 simply␈α∞cannot␈α
 manage␈α
 currently:␈α∞     viable␈α
natural␈α
language␈α∞systems,␈α
huge␈α
operating␈α∞systems,␈α
better
␈↓ d␈↓AP␈αsystems.␈α Is␈αthere␈αany␈αevidence␈αthat␈αsuch␈αhyper-productive␈αsystems␈αcould␈αever␈αbe␈αwritten?␈αThere␈αseems␈αto␈αbe
␈↓ d␈↓a␈α
manageable␈α
body␈α
of␈α
information␈α
which␈α
one␈α
needs␈α
master␈α
to␈α
do␈α
programming.␈α
 One␈α
can␈α
write␈α
 programs␈α as
␈↓ d␈↓complex␈αas␈αhe␈αwishes␈α
if␈αthe␈αprogram␈αis␈α
designed␈αin␈αa␈αclean␈α
way.␈αThus␈αthe␈αsize␈α
of␈αAP␈αsystems␈αwill␈αprobably␈α
level
␈↓ d␈↓off␈α∞ (albeit␈α∞ huge␈α∞compared␈α∞ to␈α∞ existing␈α∞ programs)␈α∂ even␈α∞as␈α∞the␈α∞size␈α∞and␈α∞complexity␈α∞of␈α∞their␈α∂generated␈α∞code
␈↓ d␈↓continues to increase and,  eventually,  surpass them.
␈↓"	
␈↓"	␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α$␈↓∧␈↓&15. References␈↓)αβ␈↓
␈↓"↔␈↓ d␈↓[1] Balzer, Robert, AIRLINE reserv. study..., 197..
␈↓"↔␈↓ d␈↓[2]␈αGadwa,␈αPeter,␈α
␈↓βSPOT,␈αa␈αmini␈α
concept␈αformation␈αprogram␈↓,␈α
Unpublished␈αMaster's␈αThesis,␈α
Artificial␈αIntelligence
␈↓"π␈↓ d␈↓Laboratory, Stanford University, Stanford, California, August, 1973.
␈↓"↔␈↓ d␈↓[3]␈α∞Green␈α∞et␈α
al.,␈α∞␈↓βProgress␈α∞Report␈α
on␈α∞Program-Understanding␈α∞Systems␈↓,␈α
Memo␈α∞AIM-240,␈α∞CS␈α∞Report␈α
STAN-CS-
␈↓"π␈↓ d␈↓74-444,Artificial Intelligence Laboratory, Stanford University, August, 1974.
␈↓"↔␈↓ d␈↓[4]␈α⊗Hempel,␈α⊗Carl␈α⊗G.,␈α⊗␈↓βFundamentals␈α⊗of␈α⊗Concept␈α⊗Formation␈α⊗in␈α⊗Empirical␈α⊗Science␈↓,␈α⊗University␈α⊗of␈α⊗Chicago,
␈↓"π␈↓ d␈↓Chicago, Illinois, 1952.
␈↓"↔␈↓ d␈↓[5]␈α⊃Hewitt,␈α⊃Carl,␈α⊃␈↓βA␈α⊃Universal␈α⊃Modular␈α⊂ACTOR␈α⊃Formalism␈α⊃for␈α⊃Artificial␈α⊃Intelligence␈↓,␈α⊃3rd␈α⊃International␈α⊂Joint
␈↓"π␈↓ d␈↓Conference on Artificial Intelligence, 1973, pp. 235-245.
␈↓"↔␈↓ d␈↓[6] Minsky, Marvin, ␈↓βFrames␈↓, in ␈↓βPsychology of Computer Vision␈↓, 1974.
␈↓"↔␈↓ d␈↓[7]␈αMinsky,␈αMarvin,␈αand␈αPapert,␈αSeymour,␈α␈↓βArtificial␈αIntelligence␈αProgress␈αReport␈↓,␈αMIT␈αProject␈αMAC,␈αAI␈αMemo
␈↓"π␈↓ d␈↓252, 1972.
␈↓"↔␈↓ d␈↓[8] Newell, Allen, and Simon, Herbert, ␈↓βHuman Problem Solving␈↓, 1973.
␈↓"↔␈↓ d␈↓[9] Sussman, G., ␈↓βHACKER␈↓ paper...
␈↓"↔␈↓ d␈↓[10] Teitelman, Warren, ␈↓βINTERLISP Reference Manual␈↓, XEROX PARC, 1974.
␈↓"↔␈↓ d␈↓[11]␈α∃Winston,␈α∃Patrick,␈α⊗␈↓βLearning␈α∃Structural␈α∃Descriptions␈α∃from␈α⊗Examples␈↓,␈α∃Ph.D.␈α∃thesis,␈α∃Dept.␈α⊗of␈α∃Electrical
␈↓"π␈↓ d␈↓Engineering, TR-76, Project MAC, TR-231, MIT AI Lab, September, 1970.
␈↓ d␈↓The␈α⊗ideas␈α⊗and␈α⊗the␈α⊗system␈α⊗described␈α∃use␈α⊗concepts␈α⊗from␈α⊗ACTORS,␈α⊗heterarchy,␈α⊗structured␈α∃programming,
␈↓"π␈↓ d␈↓assertional␈αdata␈αbases,␈αflexible␈αdata␈αtypes,␈αpattern-directed␈αinvocation␈αof␈αprocedural␈αknowledge,␈αthe␈αparadigm␈αof
␈↓"π␈↓ d␈↓dialogue,␈α
studies␈αon␈α
program␈α
specification,␈αQLISP,␈α
INTERLISP,␈αLISP,␈α
English,...␈α
In␈αparticular,␈α
the␈αauthor␈α
 drew
␈↓"π␈↓ d␈↓heavily␈αfrom␈αcreative␈αdiscussions␈αwith␈αC.␈αGreen,␈α
R.␈αWaldinger,␈αD.␈αBarstow,␈αB.␈αMcCune,␈αD.␈αShaw,␈α
E.␈αSacerdoti,
␈↓"π␈↓ d␈↓and L. Steinberg.
␈↓ d␈↓␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α0␈↓∧␈↓&Appendix: the BEINGs␈↓)αβ␈↓

␈↓ d␈↓Space␈αdoes␈αnot␈αpermit␈αdetailed␈αdiscussion␈αof␈αeach␈αBEING,␈αbut␈αthe␈αnames␈αare␈αsufficiently␈αsuggestive␈αto␈αgive␈αthe
␈↓"π␈↓ d␈↓reader a rough characterization of the knowledge in the system.

␈↓ d␈↓ADAPT:PRECONCEIVED:FUNCTION␈α?␈α?␈α ADD:DEFINITION␈α?␈α?␈α∨ADJECTIVE:HANDLER
␈↓"π␈↓ d␈↓ANALYZE:IMPLICATIONS␈α>APPLYRULE␈α>ASK:USER:ABOUT␈α?BETTER␈α>CHOOSE:FROM
␈↓"π␈↓ d␈↓CLARIFY:IMPROBABLE:SITUATION␈α=CLASSIFICATORY:CONCEPT:FORMATION␈α=COMPARE
␈↓"π␈↓ d␈↓COMPARITIVE:CONCEPT:FORMATION␈α9COMPLEX:ALTERATION␈α8COMPLEX:COMPARE:FN
␈↓"π␈↓ d␈↓COMPLEX:MODIFY:STRUCTURE␈α?␈α'CONCEPT:FORMATION␈α?␈α&CONDITIONAL:DELETION
␈↓"π␈↓ d␈↓CONDITIONAL:INSERTION␈α1CONSTRAIN␈α1CONTRADICTS␈α1DATA:STRUCTURE:DELETIONS
␈↓"π␈↓ d␈↓DATA:STRUCTURE:INSERTIONS␈α∩DEFER:DECISION␈α⊃ELEMENT␈α∩ENCODE␈α⊃EXAMINE:STRUCTURE
␈↓"π␈↓ d␈↓EXTRACT:RELEVANT:SUBSET␈α≠FAST:GET:NAME␈α≤FAST:SATISFY␈α≠FILL:IN:UNDEFINED:SECTION
␈↓"π␈↓ d␈↓FIX:INCORRECT:PIECE␈α6FOREACH␈α6GET:DATA:STRUCTURE␈α6GET:HOLD:OF␈α5GET:NAME
␈↓"π␈↓ d␈↓GET:NEW:INFORMATION␈α8GRAMMATICAL:INFERENCE␈α8INFER:CONTEXTFREE:GRAMMARS
␈↓"π␈↓ d␈↓INFER:CONTEXTSENSITIVE:GRAMMARS␈α?␈α?␈α?␈α?␈α?␈α+INFER:FIXEDCLASS:GRAMMARS
␈↓"π␈↓ d␈↓INFER:MULTICLASS:GRAMMARS␈α?␈α?␈α?␈α?␈α?␈α)INFER:PHRASESTRUCTURE:GRAMMARS
␈↓"π␈↓ d␈↓INFER:REGULAR:GRAMMARS␈α?␈α~IS:OF:TYPE␈α?␈α≠JOINING:FUNCTION␈α?␈α~LIST:STRUCTURE
␈↓"π␈↓ d␈↓MAJOR:MODIFY:STRUCTURE␈α∞MAKE:A:GUESS␈α
MAKE:ENCODABLE␈α∞MAKE:NEW:BEING␈α
MESSAGE
␈↓"π␈↓ d␈↓METRICAL:CONCEPT:FORMATION␈α.MODIFY:SOME␈α.MODIFY:STRUCTURE␈α-MODIFY:UNTIL
␈↓"π␈↓ d␈↓OBTAIN:USABLE:INFORMATION␈α$OPTIMIZE␈α$PARSE␈α%PARSE:BACKWARD␈α$PARSE:FORWARD
␈↓"π␈↓ d␈↓PARTITION:A:DOMAIN␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α?␈α.PARTITION:BY:TAKE:CLASS:GET:ELE
␈↓"π␈↓ d␈↓PARTITION:BY:TAKE:ELE:AND:CLASS␈α_PARTITION:BY:TAKE:ELE:GET:CLASS␈α↔PATTERN:MATCH
␈↓"π␈↓ d␈↓PROBABILITY=0:#␈α3PROBABILITY=1:#␈α3PROBABILITY>0&<1:#␈α2PROPOSE:PLAUSIBLE:NAMES
␈↓"π␈↓ d␈↓RECOGNIZE:ARGS␈α→RECOGNIZE:CAR␈α~RECOGNIZE:CONDITIONAL␈α→RECOGNIZE:CONJUNCTION
␈↓"π␈↓ d␈↓RECOGNIZE:EQUALITY␈α?␈α.RECOGNIZE:FUNCTION:RETURNS␈α?␈α-RECOGNIZE:INCLUSION
␈↓"π␈↓ d␈↓RECOGNIZE:LITERALS␈α?␈α?␈α/RECOGNIZE:NUMBER␈α?␈α?␈α/RECOGNIZE:SET:RELATIONS
␈↓"π␈↓ d␈↓RECOGNIZE:SOME:MEMBER␈α-RECOGNIZE:TAIL␈α.REINVESTIGATE:DECISION␈α-REPEATEDLY
␈↓"π␈↓ d␈↓RESOLVE:DECISION␈α⊗SATISFY␈α⊗SCENE␈α∃SEARCH␈α⊗SERVE␈α⊗SIMPLE:COMPARE:FN␈α∃SOME:PART:OF
␈↓"π␈↓ d␈↓STRING␈α-STRUCTURE-INDUCE␈α-STUDY:TYPE␈α-SUPPORT&DUMP␈α-TAKE:HOLD:OF␈α,TEST
␈↓"π␈↓ d␈↓TRANSLATE TRICHOTOMY USE:INFORMATION UTILIZE WHEN:NEXT WRITE:PROGRAM
␈↓"